<!DOCTYPE html> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <meta charset="utf-8"> <title>Plump</title> <meta name="viewport" content="width=device-width"> <meta name="description" content="An XML / XHTML / HTML parser that aims to be as lenient as possible."> <meta name="author" content="Nicolas Hafner &lt;shinmera@tymoon.eu&gt;"> <style type="text/css"> body{
          max-width: 1024px;
          margin: 0 auto 0 auto;
          font-family: sans-serif;
          color: #333333;
          font-size: 14pt;
          padding: 5px;
      }
      body>header{
          display:flex;
          align-items: center;
          justify-content: center;
          flex-direction: column;
          max-width: 100%;
          text-align: center;
      }
      body>header img{
          max-width: 50%;
      }
      img{
          max-width: 100%;
          max-height: 100%;
      }
      code{
          font-family: Consolas, Inconsolata, monospace;
      }
      a{
          text-decoration: none;
          color: #0055AA;
      }
      a img{
          border: none;
      }
      #documentation{
          text-align: justify;
      }
      #documentation pre{
          margin-left: 20px;
          overflow: auto;
      }
      #documentation img{
          margin: 5px;
      }
      #symbol-index>ul{
          list-style: none;
          padding: 0;
      }
      #symbol-index .package>ul{
          list-style: none;
          padding: 0 0 0 10px;
      }
      #symbol-index .package .nicknames{
          font-weight: normal;
      }
      #symbol-index .package h4{
          display: inline-block;
          margin: 0;
      }
      #symbol-index .package article{
          margin: 0 0 15px 0;
      }
      #symbol-index .package article header{
          font-size: 1.2em;
          font-weight: normal;
      }
      #symbol-index .package .name{
          margin-right: 5px;
      }
      #symbol-index .package .docstring{
          margin: 0 0 0 15px;
          white-space: pre-wrap;
          font-size: 12pt;
      }
      @media (max-width: 800px){
          body{font-size: 12pt;}
      } </style> </head> <body> <header> <h1><img alt="plump" src="plump-logo.png"></h1> <span class="version">2.0.0</span> <p class="description">An XML / XHTML / HTML parser that aims to be as lenient as possible.</p> </header> <main> <article id="documentation">  <div><h2 id="what_is_plump?">What is Plump?</h2> <p>Plump is a parser for HTML/XML like documents, focusing on being lenient towards invalid markup. It can handle things like invalid attributes, bad closing tag order, unencoded entities, inexistent tag types, self-closing tags and so on. It parses documents to a class representation and offers a small set of DOM functions to manipulate it. You are free to change it to parse to your own classes though.</p> <h2 id="how_to">How To</h2> <p>Load Plump through Quicklisp or ASDF:</p> <pre><code>(ql:quickload :plump)
</code></pre> <p>Using the <code><a href="#PLUMP-PARSER:PARSE">PARSE</a></code> function, plump will transform a string, pathname or stream into a document:</p> <pre><code>(<a href="#PLUMP:PARSE">plump:parse</a> &quot;&lt;foo&gt;&lt;bar this is=\&quot;a thing\&quot;&gt;baz&lt;/bar&gt;&lt;span id=\&quot;test\&quot;&gt;oh my&quot;)
</code></pre> <p>This returns a root node. If you want to append a document to a root node (or any other node that accepts children) that you've made, you can pass it into the parse function. To return the document into a readable form, you can call <code><a href="#PLUMP-DOM:SERIALIZE">SERIALIZE</a></code>:</p> <pre><code>(<a href="#PLUMP:SERIALIZE">plump:serialize</a> *)
</code></pre> <p>Using the DOM you can easily traverse the document and change it:</p> <pre><code>(<a href="#PLUMP:REMOVE-CHILD">plump:remove-child</a> (<a href="#PLUMP:GET-ELEMENT-BY-ID">plump:get-element-by-id</a> ** &quot;test&quot;))
(<a href="#PLUMP:SERIALIZE">plump:serialize</a> ***)
</code></pre> <p>By default plump includes a few special tag dispatchers to catch HTML oddities like self-closing tags and fulltext-nodes. Especially the self-closing tags can lead to problems in XML documents. In order to parse without any HTML &quot;tricks&quot;, you can simply do:</p> <pre><code>(<a href="http://l1sp.org/cl/let">let</a> (<a href="#PLUMP-PARSER:*TAG-DISPATCHERS*">(plump:*tag-dispatchers*</a> plump:*xml-tags*)) (<a href="#PLUMP:PARSE">plump:parse</a> &quot;&lt;link&gt;foo&lt;/link&gt;&quot;))
</code></pre> <p>This will also influence the serialization. By default self-closing tags will be printed in &quot;HTML-fashion,&quot; but if you require full XML support, the above should be the way to go. This behaviour is new in Plump2, as previously everything was always serialized in XML mode.</p> <h2 id="extending_plump">Extending Plump</h2> <p>If you want to handle a certain tag in a special way, you can write your own tag-dispatcher. For example comments, the doctype and self-closing tags are handled in this fashion. In order to properly hook in, you will have to learn to use Plump's lexer (see next section).</p> <pre><code>(<a href="#PLUMP:DEFINE-TAG-DISPATCHER">plump:define-tag-dispatcher</a> (my-dispatcher *tag-dispatchers*) (name)
  (<a href="http://l1sp.org/cl/string-equal">string-equal</a> name &quot;my-tag&quot;))

(<a href="#PLUMP:DEFINE-TAG-PARSER">plump:define-tag-parser</a> my-dispatcher (name)
  (<a href="http://l1sp.org/cl/let">let</a> ((attrs (<a href="#PLUMP:READ-ATTRIBUTES">plump:read-attributes</a>)))
    (<a href="http://l1sp.org/cl/when">when</a> (<a href="http://l1sp.org/cl/char=">char=</a> (<a href="#PLUMP:CONSUME">plump:consume</a>) #\/)
      (<a href="#PLUMP:CONSUME">plump:consume</a>)) ;; Consume closing
    (<a href="http://l1sp.org/cl/make-instance">make-instance</a> 'my-tag :parent plump:*root* :attributes attrs)))
</code></pre> <p>If you don't want to disturb the standard Plump tag dispatchers list, you can define your own special variable to contain the dispatchers and bind <code><a href="#PLUMP-PARSER:*TAG-DISPATCHERS*">*tag-dispatchers*</a></code> to that during parsing, as shown for the XML example above. Shorthand macros exist to define self-closing or full-text tags:</p> <pre><code>(<a href="#PLUMP:DEFINE-SELF-CLOSING-ELEMENT">plump:define-self-closing-element</a> img *tag-dispatchers* *html-tags*)
(<a href="#PLUMP:DEFINE-FULLTEXT-ELEMENT">plump:define-fulltext-element</a> style *tag-dispatchers* *html-tags*)
</code></pre> <p>XML allows for script tags (like <code>&lt;?php ?&gt;</code>). By default Plump does not specify any special reading for any script tag. If an unhandled script tag is encountered, a warning is emitted and Plump will try to just read anything until <code>?&gt;</code> is encountered. For most script tags this probably will not suffice, as they might contain some form of escaped <code>?&gt;</code>. If you do want to use Plump to process script tags properly as well, you will have to define your own reader with <code><a href="#PLUMP-PARSER:DEFINE-PROCESSING-PARSER">define-processing-parser</a></code>. You can also use that macro to define a reader that outputs a more suitable format than a text tag.</p> <p>During parsing, all elements are created through <code>MAKE-*</code> functions like <code><a href="#PLUMP-DOM:MAKE-ROOT">MAKE-ROOT</a></code>, <code><a href="#PLUMP-DOM:MAKE-ELEMENT">MAKE-ELEMENT</a></code>, <code><a href="#PLUMP-DOM:MAKE-TEXT-NODE">MAKE-TEXT-NODE</a></code>, and so on. By overriding these functions you can instead delegate the parsing to your own DOM.</p> <p>If you subclass the DOM classes, you might want to define a method on <code><a href="#PLUMP-DOM:SERIALIZE-OBJECT">SERIALIZE-OBJECT</a></code> to produce the right output.</p> <h2 id="plump's_lexer">Plump's Lexer</h2> <p>Since parser generators are good for strict grammars and Plump needed to be fast and lenient, it comes with its own primitive reading/lexing mechanisms. All the lexer primitives are defined in <code>lexer.lisp</code> and you can leverage them for your own projects as well, if you so desire.</p> <p>In order to allow the lexing to work, you'll have to wrap your processing code in <code><a href="#PLUMP-LEXER:WITH-LEXER-ENVIRONMENT">with-lexer-environment</a></code>. You can then use functions like <code><a href="#PLUMP-LEXER:CONSUME">consume</a></code>, <code><a href="#PLUMP-LEXER:ADVANCE">advance</a></code>, <code><a href="#PLUMP-LEXER:UNREAD">unread</a></code>, <code><a href="#PLUMP-LEXER:PEEK">peek</a></code> and <code><a href="#PLUMP-LEXER:CONSUME-UNTIL">consume-until</a></code> to process the input.</p> <p><code><a href="#PLUMP-LEXER:MAKE-MATCHER">make-matcher</a></code> allows you to use a very simple language to define matching operations. This will evaluate to a function with no arguments that should return <code>T</code> if it matches and <code>NIL</code> otherwise. Combining matchers with <code><a href="#PLUMP-LEXER:CONSUME-UNTIL">consume-until</a></code> allows you to easily make sequence readers:</p> <pre><code>(<a href="#PLUMP:WITH-LEXER-ENVIRONMENT">plump:with-lexer-environment</a> (&quot;&lt;foo&gt;&quot;)
  (<a href="http://l1sp.org/cl/when">when</a> (<a href="http://l1sp.org/cl/char=">char=</a> #\&lt; (<a href="#PLUMP:CONSUME">plump:consume</a>))
    (<a href="#PLUMP:CONSUME-UNTIL">plump:consume-until</a> (<a href="#PLUMP:MAKE-MATCHER">plump:make-matcher</a> (is #\&gt;)))))
</code></pre> <p>Available matcher constructs are <code><a href="http://l1sp.org/cl/not">not</a></code>, <code><a href="http://l1sp.org/cl/and">and</a></code>, <code><a href="http://l1sp.org/cl/or">or</a></code>, <code>is</code>, <code>in</code>, <code>next</code>, <code>prev</code>, <code>any</code>, and <code><a href="http://l1sp.org/cl/find">find</a></code>. <code><a href="#PLUMP-LEXER:DEFINE-MATCHER">define-matcher</a></code> allows you to associate keywords to matchers, which you can then use as a matcher rule in <code><a href="#PLUMP-LEXER:MAKE-MATCHER">make-matcher</a></code>. Regular symbols act as variables:</p> <pre><code>(<a href="http://l1sp.org/cl/let">let</a> ((find &quot;baz&quot;))
  (<a href="#PLUMP:WITH-LEXER-ENVIRONMENT">plump:with-lexer-environment</a> (&quot;foo bar baz&quot;)
     (<a href="#PLUMP:CONSUME-UNTIL">plump:consume-until</a> (<a href="#PLUMP:MAKE-MATCHER">plump:make-matcher</a> (is find)))))
</code></pre> <h2 id="speed">Speed</h2> <p><img src="http://shinmera.tymoon.eu/public/plump-benchmark.png" alt="benchmark"></p> <p>If you know of other native-lisp libraries that beat Plump, please do let me know, I would be very interested!</p> <h2 id="see_also">See Also</h2> <ul> <li><a href="https://shinmera.github.io/lquery/">lQuery</a> Dissect and manipulate the DOM with jQuery-like commands.</li> <li><a href="https://shinmera.github.io/CLSS/">CLSS</a> Traverse the DOM by CSS selectors.</li> <li><a href="https://github.com/Shinmera/plump-tex">plump-tex</a> Serialize between TeX and the Plump DOM.</li> <li><a href="https://github.com/Shinmera/plump-sexp">plump-sexp</a> Serialize between SEXPrs and the Plump DOM.</li> </ul> </div>  </article> <article id="copyright">  <h2>Copyright</h2> <span>plump</span> is licensed under the <span><a href="https://tldrlegal.com/search?q=Artistic">Artistic</a></span> license.  © <span>Nicolas Hafner &lt;shinmera@tymoon.eu&gt;</span> .  This library can be obtained on <a href="https://github.com/Shinmera/plump">https://github.com/Shinmera/plump</a>.  </article>  <article id="symbol-index"> <h2>Package Index</h2> <ul><li class="package"> <h3> <a name="PLUMP-LEXER" href="#PLUMP-LEXER">PLUMP-LEXER</a> <span class="nicknames">(ORG.SHIRAKUMO.PLUMP.LEXER)</span> </h3> <ul><li> <a name="PLUMP-LEXER:*INDEX*"> </a> <article id="SPECIAL PLUMP-LEXER:*INDEX*"> <header class="special"> <span class="type">special</span>  <h4 class="name"><code><a href="#SPECIAL%20PLUMP-LEXER%3A%2AINDEX%2A">*INDEX*</a></code></h4>  </header> <div class="docstring"><pre>Set to the current reading index.</pre></div> </article> </li><li> <a name="PLUMP-LEXER:*LENGTH*"> </a> <article id="SPECIAL PLUMP-LEXER:*LENGTH*"> <header class="special"> <span class="type">special</span>  <h4 class="name"><code><a href="#SPECIAL%20PLUMP-LEXER%3A%2ALENGTH%2A">*LENGTH*</a></code></h4>  </header> <div class="docstring"><pre>Set to the length of the string for bounds checking.</pre></div> </article> </li><li> <a name="PLUMP-LEXER:*STRING*"> </a> <article id="SPECIAL PLUMP-LEXER:*STRING*"> <header class="special"> <span class="type">special</span>  <h4 class="name"><code><a href="#SPECIAL%20PLUMP-LEXER%3A%2ASTRING%2A">*STRING*</a></code></h4>  </header> <div class="docstring"><pre>Contains the current string to lex.</pre></div> </article> </li><li> <a name="PLUMP-LEXER:ADVANCE"> </a> <article id="FUNCTION PLUMP-LEXER:ADVANCE"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-LEXER%3AADVANCE">ADVANCE</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code>  </header> <div class="docstring"><pre>Skips a chracter if possible.
Returns the new index or NIL.</pre></div> </article> </li><li> <a name="PLUMP-LEXER:ADVANCE-N"> </a> <article id="FUNCTION PLUMP-LEXER:ADVANCE-N"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-LEXER%3AADVANCE-N">ADVANCE-N</a></code></h4> <code class="qualifiers"></code> <code class="arguments">N</code><code>)</code>  </header> <div class="docstring"><pre>Advances by N characters if possible.
Returns the new *INDEX*.</pre></div> </article> </li><li> <a name="PLUMP-LEXER:CONSUME"> </a> <article id="FUNCTION PLUMP-LEXER:CONSUME"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-LEXER%3ACONSUME">CONSUME</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code>  </header> <div class="docstring"><pre>Consumes a single character if possible and returns it.
Otherwise returns NIL.</pre></div> </article> </li><li> <a name="PLUMP-LEXER:CONSUME-UNTIL"> </a> <article id="FUNCTION PLUMP-LEXER:CONSUME-UNTIL"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-LEXER%3ACONSUME-UNTIL">CONSUME-UNTIL</a></code></h4> <code class="qualifiers"></code> <code class="arguments">MATCHER</code><code>)</code>  </header> <div class="docstring"><pre>Consumes until the provided matcher function returns positively.
Returns the substring that was consumed.</pre></div> </article> </li><li> <a name="PLUMP-LEXER:MATCHER-AND"> </a> <article id="FUNCTION PLUMP-LEXER:MATCHER-AND"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-LEXER%3AMATCHER-AND">MATCHER-AND</a></code></h4> <code class="qualifiers"></code> <code class="arguments">&amp;REST MATCHERS</code><code>)</code>  </header> <div class="docstring"><pre>Creates a matcher function that returns if all of the sub-expressions
return successfully. The last match is returned, if all.</pre></div> </article> </li><li> <a name="PLUMP-LEXER:MATCHER-CHARACTER"> </a> <article id="FUNCTION PLUMP-LEXER:MATCHER-CHARACTER"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-LEXER%3AMATCHER-CHARACTER">MATCHER-CHARACTER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHARACTER</code><code>)</code>  </header> <div class="docstring"><pre>Creates a matcher function that attempts to match the given character.</pre></div> </article> </li><li> <a name="PLUMP-LEXER:MATCHER-FIND"> </a> <article id="FUNCTION PLUMP-LEXER:MATCHER-FIND"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-LEXER%3AMATCHER-FIND">MATCHER-FIND</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code>  </header> <div class="docstring"><pre>Creates a matcher function that returns T if the character is found in the given list.</pre></div> </article> </li><li> <a name="PLUMP-LEXER:MATCHER-NEXT"> </a> <article id="FUNCTION PLUMP-LEXER:MATCHER-NEXT"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-LEXER%3AMATCHER-NEXT">MATCHER-NEXT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">MATCHER</code><code>)</code>  </header> <div class="docstring"><pre>Creates a matcher environment that peeks ahead one farther.</pre></div> </article> </li><li> <a name="PLUMP-LEXER:MATCHER-NOT"> </a> <article id="FUNCTION PLUMP-LEXER:MATCHER-NOT"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-LEXER%3AMATCHER-NOT">MATCHER-NOT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">MATCHER</code><code>)</code>  </header> <div class="docstring"><pre>Creates a matcher function that inverts the result of the sub-expression.</pre></div> </article> </li><li> <a name="PLUMP-LEXER:MATCHER-OR"> </a> <article id="FUNCTION PLUMP-LEXER:MATCHER-OR"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-LEXER%3AMATCHER-OR">MATCHER-OR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">&amp;REST MATCHERS</code><code>)</code>  </header> <div class="docstring"><pre>Creates a matcher function that returns successfully if any of the
sub-expressions return successfully. The first match is returned, if any.</pre></div> </article> </li><li> <a name="PLUMP-LEXER:MATCHER-PREV"> </a> <article id="FUNCTION PLUMP-LEXER:MATCHER-PREV"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-LEXER%3AMATCHER-PREV">MATCHER-PREV</a></code></h4> <code class="qualifiers"></code> <code class="arguments">MATCHER</code><code>)</code>  </header> <div class="docstring"><pre>Creates a matcher environment that peeks behind.</pre></div> </article> </li><li> <a name="PLUMP-LEXER:MATCHER-RANGE"> </a> <article id="FUNCTION PLUMP-LEXER:MATCHER-RANGE"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-LEXER%3AMATCHER-RANGE">MATCHER-RANGE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">FROM TO</code><code>)</code>  </header> <div class="docstring"><pre>Creates a matcher that checks a range according to the next character's CHAR-CODE.</pre></div> </article> </li><li> <a name="PLUMP-LEXER:MATCHER-STRING"> </a> <article id="FUNCTION PLUMP-LEXER:MATCHER-STRING"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-LEXER%3AMATCHER-STRING">MATCHER-STRING</a></code></h4> <code class="qualifiers"></code> <code class="arguments">STRING</code><code>)</code>  </header> <div class="docstring"><pre>Creates a matcher function that attempts to match the given string.</pre></div> </article> </li><li> <a name="PLUMP-LEXER:PEEK"> </a> <article id="FUNCTION PLUMP-LEXER:PEEK"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-LEXER%3APEEK">PEEK</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code>  </header> <div class="docstring"><pre>Returns the next character, if any.</pre></div> </article> </li><li> <a name="PLUMP-LEXER:UNREAD"> </a> <article id="FUNCTION PLUMP-LEXER:UNREAD"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-LEXER%3AUNREAD">UNREAD</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code>  </header> <div class="docstring"><pre>Steps back a single character if possible.
Returns the new *INDEX*.</pre></div> </article> </li><li> <a name="PLUMP-LEXER:UNREAD-N"> </a> <article id="FUNCTION PLUMP-LEXER:UNREAD-N"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-LEXER%3AUNREAD-N">UNREAD-N</a></code></h4> <code class="qualifiers"></code> <code class="arguments">N</code><code>)</code>  </header> <div class="docstring"><pre>Steps back by N characters if possible.
Returns the new *INDEX*.</pre></div> </article> </li><li> <a name="PLUMP-LEXER:DEFINE-MATCHER"> </a> <article id="MACRO PLUMP-LEXER:DEFINE-MATCHER"> <header class="macro"> <span class="type">macro</span>  <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP-LEXER%3ADEFINE-MATCHER">DEFINE-MATCHER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NAME FORM</code><code>)</code>  </header> <div class="docstring"><pre>Associates NAME as a keyword to the matcher form. You can then use the keyword in further matcher rules.</pre></div> </article> </li><li> <a name="PLUMP-LEXER:MAKE-MATCHER"> </a> <article id="MACRO PLUMP-LEXER:MAKE-MATCHER"> <header class="macro"> <span class="type">macro</span>  <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP-LEXER%3AMAKE-MATCHER">MAKE-MATCHER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">FORM</code><code>)</code>  </header> <div class="docstring"><pre>Macro to create a matcher chain.</pre></div> </article> </li><li> <a name="PLUMP-LEXER:MATCHER-ANY"> </a> <article id="MACRO PLUMP-LEXER:MATCHER-ANY"> <header class="macro"> <span class="type">macro</span>  <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP-LEXER%3AMATCHER-ANY">MATCHER-ANY</a></code></h4> <code class="qualifiers"></code> <code class="arguments">&amp;REST IS</code><code>)</code>  </header> <div class="docstring"><pre>Shorthand for (or (is a) (is b)..)</pre></div> </article> </li><li> <a name="PLUMP-LEXER:WITH-LEXER-ENVIRONMENT"> </a> <article id="MACRO PLUMP-LEXER:WITH-LEXER-ENVIRONMENT"> <header class="macro"> <span class="type">macro</span>  <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP-LEXER%3AWITH-LEXER-ENVIRONMENT">WITH-LEXER-ENVIRONMENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">(STRING) &amp;BODY BODY</code><code>)</code>  </header> <div class="docstring"><pre>Sets up the required lexing environment for the given string.</pre></div> </article> </li></ul> </li><li class="package"> <h3> <a name="PLUMP-DOM" href="#PLUMP-DOM">PLUMP-DOM</a> <span class="nicknames">(ORG.SHIRAKUMO.PLUMP.DOM)</span> </h3> <ul><li> <a name="PLUMP-DOM:*ENTITY-MAP*"> </a> <article id="SPECIAL PLUMP-DOM:*ENTITY-MAP*"> <header class="special"> <span class="type">special</span>  <h4 class="name"><code><a href="#SPECIAL%20PLUMP-DOM%3A%2AENTITY-MAP%2A">*ENTITY-MAP*</a></code></h4>  </header> <div class="docstring"><pre>String hash-table containing the entity names and mapping them to their respective characters.</pre></div> </article> </li><li> <a name="PLUMP-DOM:*STREAM*"> </a> <article id="SPECIAL PLUMP-DOM:*STREAM*"> <header class="special"> <span class="type">special</span>  <h4 class="name"><code><a href="#SPECIAL%20PLUMP-DOM%3A%2ASTREAM%2A">*STREAM*</a></code></h4>  </header> <div class="docstring"><pre>The stream to serialize to during SERIALIZE-OBJECT.</pre></div> </article> </li><li> <a name="PLUMP-DOM:CDATA"> </a> <article id="CLASS PLUMP-DOM:CDATA"> <header class="class"> <span class="type">class</span>  <h4 class="name"><code><a href="#CLASS%20PLUMP-DOM%3ACDATA">CDATA</a></code></h4>  </header> <div class="docstring"><pre>XML CDATA section node.</pre></div> </article> </li><li> <a name="PLUMP-DOM:CHILD-NODE"> </a> <article id="CLASS PLUMP-DOM:CHILD-NODE"> <header class="class"> <span class="type">class</span>  <h4 class="name"><code><a href="#CLASS%20PLUMP-DOM%3ACHILD-NODE">CHILD-NODE</a></code></h4>  </header> <div class="docstring"><pre>Node class that is a child and thus has a parent.</pre></div> </article> </li><li> <a name="PLUMP-DOM:COMMENT"> </a> <article id="CLASS PLUMP-DOM:COMMENT"> <header class="class"> <span class="type">class</span>  <h4 class="name"><code><a href="#CLASS%20PLUMP-DOM%3ACOMMENT">COMMENT</a></code></h4>  </header> <div class="docstring"><pre>Comment node that can only contain a single comment string.</pre></div> </article> </li><li> <a name="PLUMP-DOM:DOCTYPE"> </a> <article id="CLASS PLUMP-DOM:DOCTYPE"> <header class="class"> <span class="type">class</span>  <h4 class="name"><code><a href="#CLASS%20PLUMP-DOM%3ADOCTYPE">DOCTYPE</a></code></h4>  </header> <div class="docstring"><pre>Special DOM node for the doctype declaration.</pre></div> </article> </li><li> <a name="PLUMP-DOM:ELEMENT"> </a> <article id="CLASS PLUMP-DOM:ELEMENT"> <header class="class"> <span class="type">class</span>  <h4 class="name"><code><a href="#CLASS%20PLUMP-DOM%3AELEMENT">ELEMENT</a></code></h4>  </header> <div class="docstring"><pre>Standard DOM element/block including attributes, tag-name, parent and children.</pre></div> </article> </li><li> <a name="PLUMP-DOM:FULLTEXT-ELEMENT"> </a> <article id="CLASS PLUMP-DOM:FULLTEXT-ELEMENT"> <header class="class"> <span class="type">class</span>  <h4 class="name"><code><a href="#CLASS%20PLUMP-DOM%3AFULLTEXT-ELEMENT">FULLTEXT-ELEMENT</a></code></h4>  </header> <div class="docstring"><pre>Special DOM element that contains full, un-entitied text like SCRIPT and STYLE.</pre></div> </article> </li><li> <a name="PLUMP-DOM:NESTING-NODE"> </a> <article id="CLASS PLUMP-DOM:NESTING-NODE"> <header class="class"> <span class="type">class</span>  <h4 class="name"><code><a href="#CLASS%20PLUMP-DOM%3ANESTING-NODE">NESTING-NODE</a></code></h4>  </header> <div class="docstring"><pre>Node class that can contain child nodes.</pre></div> </article> </li><li> <a name="PLUMP-DOM:NODE"> </a> <article id="CLASS PLUMP-DOM:NODE"> <header class="class"> <span class="type">class</span>  <h4 class="name"><code><a href="#CLASS%20PLUMP-DOM%3ANODE">NODE</a></code></h4>  </header> <div class="docstring"><pre>Base DOM node class.</pre></div> </article> </li><li> <a name="PLUMP-DOM:PROCESSING-INSTRUCTION"> </a> <article id="CLASS PLUMP-DOM:PROCESSING-INSTRUCTION"> <header class="class"> <span class="type">class</span>  <h4 class="name"><code><a href="#CLASS%20PLUMP-DOM%3APROCESSING-INSTRUCTION">PROCESSING-INSTRUCTION</a></code></h4>  </header> <div class="docstring"><pre>XML processing instruction node.</pre></div> </article> </li><li> <a name="PLUMP-DOM:ROOT"> </a> <article id="CLASS PLUMP-DOM:ROOT"> <header class="class"> <span class="type">class</span>  <h4 class="name"><code><a href="#CLASS%20PLUMP-DOM%3AROOT">ROOT</a></code></h4>  </header> <div class="docstring"><pre>Root DOM node, practically equivalent to a &quot;document&quot;.</pre></div> </article> </li><li> <a name="PLUMP-DOM:TEXT-NODE"> </a> <article id="CLASS PLUMP-DOM:TEXT-NODE"> <header class="class"> <span class="type">class</span>  <h4 class="name"><code><a href="#CLASS%20PLUMP-DOM%3ATEXT-NODE">TEXT-NODE</a></code></h4>  </header> <div class="docstring"><pre>Text node that can only contain a single text string.</pre></div> </article> </li><li> <a name="PLUMP-DOM:TEXTUAL-NODE"> </a> <article id="CLASS PLUMP-DOM:TEXTUAL-NODE"> <header class="class"> <span class="type">class</span>  <h4 class="name"><code><a href="#CLASS%20PLUMP-DOM%3ATEXTUAL-NODE">TEXTUAL-NODE</a></code></h4>  </header> <div class="docstring"><pre>Node class that represents a textual node and thus contains a TEXT field.</pre></div> </article> </li><li> <a name="PLUMP-DOM:XML-HEADER"> </a> <article id="CLASS PLUMP-DOM:XML-HEADER"> <header class="class"> <span class="type">class</span>  <h4 class="name"><code><a href="#CLASS%20PLUMP-DOM%3AXML-HEADER">XML-HEADER</a></code></h4>  </header> <div class="docstring"><pre>XML header element</pre></div> </article> </li><li> <a name="PLUMP-DOM:DISCOURAGED-XML-CHARACTER"> </a> <article id="CONDITION PLUMP-DOM:DISCOURAGED-XML-CHARACTER"> <header class="condition"> <span class="type">condition</span>  <h4 class="name"><code><a href="#CONDITION%20PLUMP-DOM%3ADISCOURAGED-XML-CHARACTER">DISCOURAGED-XML-CHARACTER</a></code></h4>  </header> <div class="docstring"><pre>Warning signalled when a discouraged XML character is encountered during WRITE-ENCODE-CHAR.</pre></div> </article> </li><li> <a name="PLUMP-DOM:INVALID-XML-CHARACTER"> </a> <article id="CONDITION PLUMP-DOM:INVALID-XML-CHARACTER"> <header class="condition"> <span class="type">condition</span>  <h4 class="name"><code><a href="#CONDITION%20PLUMP-DOM%3AINVALID-XML-CHARACTER">INVALID-XML-CHARACTER</a></code></h4>  </header> <div class="docstring"><pre>Error signalled when an invalid XML character is encountered during WRITE-ENCODE-CHAR.</pre></div> </article> </li><li> <a name="PLUMP-DOM:ATTRIBUTE"> </a> <article id="ACCESSOR PLUMP-DOM:ATTRIBUTE"> <header class="accessor"> <span class="type">accessor</span>  <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20PLUMP-DOM%3AATTRIBUTE">ATTRIBUTE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT ATTRIBUTE</code><code>)</code>  </header> <div class="docstring"><pre>Returns the asked attribute from the element
or NIL. If the attribute could not be found, the
second return value is set to NIL.</pre></div> </article> </li><li> <a name="PLUMP-DOM:ATTRIBUTES"> </a> <article id="ACCESSOR PLUMP-DOM:ATTRIBUTES"> <header class="accessor"> <span class="type">accessor</span>  <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20PLUMP-DOM%3AATTRIBUTES">ATTRIBUTES</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code>  </header> <div class="docstring"><pre>Returns an EQUALP hash-table of the element's attributes.</pre></div> </article> </li><li> <a name="PLUMP-DOM:CHILDREN"> </a> <article id="ACCESSOR PLUMP-DOM:CHILDREN"> <header class="accessor"> <span class="type">accessor</span>  <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20PLUMP-DOM%3ACHILDREN">CHILDREN</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code>  </header> <div class="docstring"><pre>Returns a vector of child-nodes that are contained within the node.</pre></div> </article> </li><li> <a name="PLUMP-DOM:DOCTYPE"> </a> <article id="ACCESSOR PLUMP-DOM:DOCTYPE"> <header class="accessor"> <span class="type">accessor</span>  <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20PLUMP-DOM%3ADOCTYPE">DOCTYPE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code>  </header> <div class="docstring"><pre>Returns the doctype node's actual doctype string.</pre></div> </article> </li><li> <a name="PLUMP-DOM:FAULTY-CHAR"> </a> <article id="ACCESSOR PLUMP-DOM:FAULTY-CHAR"> <header class="accessor"> <span class="type">accessor</span>  <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20PLUMP-DOM%3AFAULTY-CHAR">FAULTY-CHAR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CONDITION</code><code>)</code>  </header> <div class="docstring"><pre>Returns the faulty char that caused the signal.</pre></div> </article> </li><li> <a name="PLUMP-DOM:PARENT"> </a> <article id="ACCESSOR PLUMP-DOM:PARENT"> <header class="accessor"> <span class="type">accessor</span>  <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20PLUMP-DOM%3APARENT">PARENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code>  </header> <div class="docstring"><pre>Returns the node's parent that should contain this element as a child.</pre></div> </article> </li><li> <a name="PLUMP-DOM:TAG-NAME"> </a> <article id="ACCESSOR PLUMP-DOM:TAG-NAME"> <header class="accessor"> <span class="type">accessor</span>  <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20PLUMP-DOM%3ATAG-NAME">TAG-NAME</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code>  </header> <div class="docstring"><pre>Returns the element's tag name.</pre></div> </article> </li><li> <a name="PLUMP-DOM:TEXT"> </a> <article id="ACCESSOR PLUMP-DOM:TEXT"> <header class="accessor"> <span class="type">accessor</span>  <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20PLUMP-DOM%3ATEXT">TEXT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code>  </header> <div class="docstring"><pre>Returns the node's textual content.</pre></div> </article> </li><li> <a name="PLUMP-DOM:ALLOWED-CHAR-P"> </a> <article id="FUNCTION PLUMP-DOM:ALLOWED-CHAR-P"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AALLOWED-CHAR-P">ALLOWED-CHAR-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHAR</code><code>)</code>  </header> <div class="docstring"><pre>Returns T if the character is a permitted XML character.</pre></div> </article> </li><li> <a name="PLUMP-DOM:APPEND-CHILD"> </a> <article id="FUNCTION PLUMP-DOM:APPEND-CHILD"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AAPPEND-CHILD">APPEND-CHILD</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PARENT CHILD</code><code>)</code>  </header> <div class="docstring"><pre>Appends the given child onto the parent's child list.
Returns the child.</pre></div> </article> </li><li> <a name="PLUMP-DOM:CDATA-P"> </a> <article id="FUNCTION PLUMP-DOM:CDATA-P"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ACDATA-P">CDATA-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code>  </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type CDATA</pre></div> </article> </li><li> <a name="PLUMP-DOM:CHILD-ELEMENTS"> </a> <article id="FUNCTION PLUMP-DOM:CHILD-ELEMENTS"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ACHILD-ELEMENTS">CHILD-ELEMENTS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NESTING-NODE</code><code>)</code>  </header> <div class="docstring"><pre>Returns a new vector of children of the given node, filtered to elements.</pre></div> </article> </li><li> <a name="PLUMP-DOM:CHILD-NODE-P"> </a> <article id="FUNCTION PLUMP-DOM:CHILD-NODE-P"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ACHILD-NODE-P">CHILD-NODE-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code>  </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type CHILD-NODE</pre></div> </article> </li><li> <a name="PLUMP-DOM:CHILD-POSITION"> </a> <article id="FUNCTION PLUMP-DOM:CHILD-POSITION"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ACHILD-POSITION">CHILD-POSITION</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHILD</code><code>)</code>  </header> <div class="docstring"><pre>Returns the index of the child within its parent.</pre></div> </article> </li><li> <a name="PLUMP-DOM:CLEAR"> </a> <article id="FUNCTION PLUMP-DOM:CLEAR"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ACLEAR">CLEAR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NESTING-NODE</code><code>)</code>  </header> <div class="docstring"><pre>Clears all children from the node.

Noe that the PARENT of all child elements is set to NIL.</pre></div> </article> </li><li> <a name="PLUMP-DOM:CLONE-ATTRIBUTES"> </a> <article id="FUNCTION PLUMP-DOM:CLONE-ATTRIBUTES"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ACLONE-ATTRIBUTES">CLONE-ATTRIBUTES</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE</code><code>)</code>  </header> <div class="docstring"><pre>Clone the attribute map.
Note that keys and values are NOT copied/cloned.</pre></div> </article> </li><li> <a name="PLUMP-DOM:CLONE-CHILDREN"> </a> <article id="FUNCTION PLUMP-DOM:CLONE-CHILDREN"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ACLONE-CHILDREN">CLONE-CHILDREN</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE &amp;OPTIONAL DEEP NEW-PARENT</code><code>)</code>  </header> <div class="docstring"><pre>Clone the array of children.
If DEEP is non-NIL, each child is cloned as per (CLONE-NODE NODE T).
When copying deeply, you can also pass a NEW-PARENT to set on each child.</pre></div> </article> </li><li> <a name="PLUMP-DOM:COMMENT-P"> </a> <article id="FUNCTION PLUMP-DOM:COMMENT-P"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ACOMMENT-P">COMMENT-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code>  </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type COMMENT</pre></div> </article> </li><li> <a name="PLUMP-DOM:DECODE-ENTITIES"> </a> <article id="FUNCTION PLUMP-DOM:DECODE-ENTITIES"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ADECODE-ENTITIES">DECODE-ENTITIES</a></code></h4> <code class="qualifiers"></code> <code class="arguments">TEXT &amp;OPTIONAL REMOVE-INVALID</code><code>)</code>  </header> <div class="docstring"><pre>Translates all entities in the text into their character counterparts if possible.
If an entity does not match, it is left in place unless REMOVE-INVALID is non-NIL.</pre></div> </article> </li><li> <a name="PLUMP-DOM:DISCOURAGED-CHAR-P"> </a> <article id="FUNCTION PLUMP-DOM:DISCOURAGED-CHAR-P"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ADISCOURAGED-CHAR-P">DISCOURAGED-CHAR-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHAR</code><code>)</code>  </header> <div class="docstring"><pre>Returns T if the character is a discouraged XML character.</pre></div> </article> </li><li> <a name="PLUMP-DOM:DOCTYPE-P"> </a> <article id="FUNCTION PLUMP-DOM:DOCTYPE-P"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ADOCTYPE-P">DOCTYPE-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code>  </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type DOCTYPE</pre></div> </article> </li><li> <a name="PLUMP-DOM:ELEMENT-P"> </a> <article id="FUNCTION PLUMP-DOM:ELEMENT-P"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AELEMENT-P">ELEMENT-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code>  </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type ELEMENT</pre></div> </article> </li><li> <a name="PLUMP-DOM:ELEMENT-POSITION"> </a> <article id="FUNCTION PLUMP-DOM:ELEMENT-POSITION"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AELEMENT-POSITION">ELEMENT-POSITION</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHILD</code><code>)</code>  </header> <div class="docstring"><pre>Returns the index of the child within its parent, counting only elements.
This excludes comments, text-nodes and the like.</pre></div> </article> </li><li> <a name="PLUMP-DOM:ENCODE-ENTITIES"> </a> <article id="FUNCTION PLUMP-DOM:ENCODE-ENTITIES"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AENCODE-ENTITIES">ENCODE-ENTITIES</a></code></h4> <code class="qualifiers"></code> <code class="arguments">TEXT &amp;OPTIONAL STREAM</code><code>)</code>  </header> <div class="docstring"><pre>Encodes the characters &lt; &gt; &amp; &quot; with their XML entity equivalents.

If no STREAM is given, it encodes to a new string.</pre></div> </article> </li><li> <a name="PLUMP-DOM:ENSURE-ATTRIBUTE-MAP"> </a> <article id="FUNCTION PLUMP-DOM:ENSURE-ATTRIBUTE-MAP"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AENSURE-ATTRIBUTE-MAP">ENSURE-ATTRIBUTE-MAP</a></code></h4> <code class="qualifiers"></code> <code class="arguments">TABLE</code><code>)</code>  </header> <div class="docstring"><pre>Ensures that the TABLE is suitable as an attribute-map.
If it is not, the table is copied into a proper attribute-map.</pre></div> </article> </li><li> <a name="PLUMP-DOM:ENSURE-CHILD-ARRAY"> </a> <article id="FUNCTION PLUMP-DOM:ENSURE-CHILD-ARRAY"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AENSURE-CHILD-ARRAY">ENSURE-CHILD-ARRAY</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ARRAY</code><code>)</code>  </header> <div class="docstring"><pre>If the ARRAY is suitable as a child-array, it is returned.
Otherwise the array's elements are copied over into a proper
child-array.</pre></div> </article> </li><li> <a name="PLUMP-DOM:FAMILY"> </a> <article id="FUNCTION PLUMP-DOM:FAMILY"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AFAMILY">FAMILY</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHILD</code><code>)</code>  </header> <div class="docstring"><pre>Returns the direct array of children of the parent of the given child.
Note that modifying this array directly modifies that of the parent.</pre></div> </article> </li><li> <a name="PLUMP-DOM:FAMILY-ELEMENTS"> </a> <article id="FUNCTION PLUMP-DOM:FAMILY-ELEMENTS"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AFAMILY-ELEMENTS">FAMILY-ELEMENTS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHILD</code><code>)</code>  </header> <div class="docstring"><pre>Returns the direct array of children elements of the parent of the given child.
Note that this is a copy of the array, modifying it is safe.
This excludes comments, text-nodes and the like.</pre></div> </article> </li><li> <a name="PLUMP-DOM:FIRST-CHILD"> </a> <article id="FUNCTION PLUMP-DOM:FIRST-CHILD"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AFIRST-CHILD">FIRST-CHILD</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT</code><code>)</code>  </header> <div class="docstring"><pre>Returns the first child within the parent or NIL
if the parent is empty.</pre></div> </article> </li><li> <a name="PLUMP-DOM:FIRST-ELEMENT"> </a> <article id="FUNCTION PLUMP-DOM:FIRST-ELEMENT"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AFIRST-ELEMENT">FIRST-ELEMENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT</code><code>)</code>  </header> <div class="docstring"><pre>Returns the first child element within the parent or NIL
if the parent is empty. This excludes comments, text-nodes and the like.</pre></div> </article> </li><li> <a name="PLUMP-DOM:FULLTEXT-ELEMENT-P"> </a> <article id="FUNCTION PLUMP-DOM:FULLTEXT-ELEMENT-P"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AFULLTEXT-ELEMENT-P">FULLTEXT-ELEMENT-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code>  </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type FULLTEXT-ELEMENT</pre></div> </article> </li><li> <a name="PLUMP-DOM:GET-ATTRIBUTE"> </a> <article id="FUNCTION PLUMP-DOM:GET-ATTRIBUTE"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AGET-ATTRIBUTE">GET-ATTRIBUTE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT ATTRIBUTE</code><code>)</code>  </header> <div class="docstring"><pre>Synonymous to ATTRIBUTE.</pre></div> </article> </li><li> <a name="PLUMP-DOM:GET-ELEMENT-BY-ID"> </a> <article id="FUNCTION PLUMP-DOM:GET-ELEMENT-BY-ID"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AGET-ELEMENT-BY-ID">GET-ELEMENT-BY-ID</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE ID</code><code>)</code>  </header> <div class="docstring"><pre>Searches the given node and returns the first
node at arbitrary depth that matches the given ID
attribute.</pre></div> </article> </li><li> <a name="PLUMP-DOM:GET-ELEMENTS-BY-TAG-NAME"> </a> <article id="FUNCTION PLUMP-DOM:GET-ELEMENTS-BY-TAG-NAME"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AGET-ELEMENTS-BY-TAG-NAME">GET-ELEMENTS-BY-TAG-NAME</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE TAG</code><code>)</code>  </header> <div class="docstring"><pre>Searches the given node and returns an unordered
list of child nodes at arbitrary depth that match
the given tag.</pre></div> </article> </li><li> <a name="PLUMP-DOM:HAS-ATTRIBUTE"> </a> <article id="FUNCTION PLUMP-DOM:HAS-ATTRIBUTE"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AHAS-ATTRIBUTE">HAS-ATTRIBUTE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT ATTRIBUTE</code><code>)</code>  </header> <div class="docstring"><pre>Returns T if the provided attribute exists.</pre></div> </article> </li><li> <a name="PLUMP-DOM:HAS-CHILD-NODES"> </a> <article id="FUNCTION PLUMP-DOM:HAS-CHILD-NODES"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AHAS-CHILD-NODES">HAS-CHILD-NODES</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE</code><code>)</code>  </header> <div class="docstring"><pre>Returns T if the node can contain children and
the child array is not empty.</pre></div> </article> </li><li> <a name="PLUMP-DOM:INSERT-AFTER"> </a> <article id="FUNCTION PLUMP-DOM:INSERT-AFTER"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AINSERT-AFTER">INSERT-AFTER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT NEW-CHILD</code><code>)</code>  </header> <div class="docstring"><pre>Inserts the new-child after the given element in the parent's list.
Returns the new child.

Note that this operation is potentially very costly.
See <a href="NIL">VECTOR-PUSH-EXTEND-POSITION</a></pre></div> </article> </li><li> <a name="PLUMP-DOM:INSERT-BEFORE"> </a> <article id="FUNCTION PLUMP-DOM:INSERT-BEFORE"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AINSERT-BEFORE">INSERT-BEFORE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT NEW-CHILD</code><code>)</code>  </header> <div class="docstring"><pre>Inserts the new-child before the given element in the parent's list.
Returns the new child.

Note that this operation is potentially very costly.
See <a href="NIL">VECTOR-PUSH-EXTEND-POSITION</a></pre></div> </article> </li><li> <a name="PLUMP-DOM:LAST-CHILD"> </a> <article id="FUNCTION PLUMP-DOM:LAST-CHILD"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ALAST-CHILD">LAST-CHILD</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT</code><code>)</code>  </header> <div class="docstring"><pre>Returns the last child within the parent or NIL
if the parent is empty.</pre></div> </article> </li><li> <a name="PLUMP-DOM:LAST-ELEMENT"> </a> <article id="FUNCTION PLUMP-DOM:LAST-ELEMENT"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ALAST-ELEMENT">LAST-ELEMENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT</code><code>)</code>  </header> <div class="docstring"><pre>Returns the last child element within the parent or NIL
if the parent is empty. This excludes comments, text-nodes and the like.</pre></div> </article> </li><li> <a name="PLUMP-DOM:MAKE-ATTRIBUTE-MAP"> </a> <article id="FUNCTION PLUMP-DOM:MAKE-ATTRIBUTE-MAP"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AMAKE-ATTRIBUTE-MAP">MAKE-ATTRIBUTE-MAP</a></code></h4> <code class="qualifiers"></code> <code class="arguments">&amp;OPTIONAL (SIZE 0)</code><code>)</code>  </header> <div class="docstring"><pre>Creates a map to contain attributes.</pre></div> </article> </li><li> <a name="PLUMP-DOM:MAKE-CDATA"> </a> <article id="FUNCTION PLUMP-DOM:MAKE-CDATA"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AMAKE-CDATA">MAKE-CDATA</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PARENT &amp;KEY (TEXT &quot;&quot;)</code><code>)</code>  </header> <div class="docstring"><pre>Creates an XML CDATA section under the parent.

Note that the element is automatically appended to the parent's child list.</pre></div> </article> </li><li> <a name="PLUMP-DOM:MAKE-CHILD-ARRAY"> </a> <article id="FUNCTION PLUMP-DOM:MAKE-CHILD-ARRAY"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AMAKE-CHILD-ARRAY">MAKE-CHILD-ARRAY</a></code></h4> <code class="qualifiers"></code> <code class="arguments">&amp;OPTIONAL (SIZE 0)</code><code>)</code>  </header> <div class="docstring"><pre>Creates an array to contain child elements</pre></div> </article> </li><li> <a name="PLUMP-DOM:MAKE-COMMENT"> </a> <article id="FUNCTION PLUMP-DOM:MAKE-COMMENT"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AMAKE-COMMENT">MAKE-COMMENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PARENT &amp;OPTIONAL (TEXT &quot;&quot;)</code><code>)</code>  </header> <div class="docstring"><pre>Creates a new comment node under the parent.

Note that the node is automatically appended to the parent's child list.</pre></div> </article> </li><li> <a name="PLUMP-DOM:MAKE-DOCTYPE"> </a> <article id="FUNCTION PLUMP-DOM:MAKE-DOCTYPE"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AMAKE-DOCTYPE">MAKE-DOCTYPE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PARENT DOCTYPE</code><code>)</code>  </header> <div class="docstring"><pre>Creates a new doctype node under the parent.

Note that the node is automatically appended to the parent's child list.</pre></div> </article> </li><li> <a name="PLUMP-DOM:MAKE-ELEMENT"> </a> <article id="FUNCTION PLUMP-DOM:MAKE-ELEMENT"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AMAKE-ELEMENT">MAKE-ELEMENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PARENT TAG &amp;KEY (CHILDREN (MAKE-CHILD-ARRAY))
 (ATTRIBUTES (MAKE-ATTRIBUTE-MAP))</code><code>)</code>  </header> <div class="docstring"><pre>Creates a standard DOM element with the given tag name and parent.
Optionally a vector (with fill-pointer) containing children and an
attribute-map (a hash-table with equalp test) can be supplied.

Note that the element is automatically appended to the parent's child list.</pre></div> </article> </li><li> <a name="PLUMP-DOM:MAKE-FULLTEXT-ELEMENT"> </a> <article id="FUNCTION PLUMP-DOM:MAKE-FULLTEXT-ELEMENT"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AMAKE-FULLTEXT-ELEMENT">MAKE-FULLTEXT-ELEMENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PARENT TAG &amp;KEY TEXT (ATTRIBUTES (MAKE-ATTRIBUTE-MAP))</code><code>)</code>  </header> <div class="docstring"><pre>Creates a fulltext element under the parent.
Optionally a text and an attribute-map (a hash-table with equalp test) 
can be supplied.

Note that the element is automatically appended to the parent's child list.</pre></div> </article> </li><li> <a name="PLUMP-DOM:MAKE-PROCESSING-INSTRUCTION"> </a> <article id="FUNCTION PLUMP-DOM:MAKE-PROCESSING-INSTRUCTION"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AMAKE-PROCESSING-INSTRUCTION">MAKE-PROCESSING-INSTRUCTION</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PARENT &amp;KEY NAME (TEXT &quot;&quot;)</code><code>)</code>  </header> <div class="docstring"><pre>Creates an XML processing instruction under the parent.

Note that the element is automatically appended to the parent's child list.</pre></div> </article> </li><li> <a name="PLUMP-DOM:MAKE-ROOT"> </a> <article id="FUNCTION PLUMP-DOM:MAKE-ROOT"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AMAKE-ROOT">MAKE-ROOT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">&amp;OPTIONAL (CHILDREN (MAKE-CHILD-ARRAY))</code><code>)</code>  </header> <div class="docstring"><pre>Creates a root node with the given children.
Children should be a vector with fill-pointer.</pre></div> </article> </li><li> <a name="PLUMP-DOM:MAKE-TEXT-NODE"> </a> <article id="FUNCTION PLUMP-DOM:MAKE-TEXT-NODE"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AMAKE-TEXT-NODE">MAKE-TEXT-NODE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PARENT &amp;OPTIONAL (TEXT &quot;&quot;)</code><code>)</code>  </header> <div class="docstring"><pre>Creates a new text node under the parent.

Note that the node is automatically appended to the parent's child list.</pre></div> </article> </li><li> <a name="PLUMP-DOM:MAKE-XML-HEADER"> </a> <article id="FUNCTION PLUMP-DOM:MAKE-XML-HEADER"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AMAKE-XML-HEADER">MAKE-XML-HEADER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PARENT &amp;KEY (ATTRIBUTES (MAKE-ATTRIBUTE-MAP))</code><code>)</code>  </header> <div class="docstring"><pre>Creates an XML header object under the parent.

Note that the element is automatically appended to the parent's child list.</pre></div> </article> </li><li> <a name="PLUMP-DOM:NESTING-NODE-P"> </a> <article id="FUNCTION PLUMP-DOM:NESTING-NODE-P"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ANESTING-NODE-P">NESTING-NODE-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code>  </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type NESTING-NODE</pre></div> </article> </li><li> <a name="PLUMP-DOM:NEXT-ELEMENT"> </a> <article id="FUNCTION PLUMP-DOM:NEXT-ELEMENT"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ANEXT-ELEMENT">NEXT-ELEMENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHILD</code><code>)</code>  </header> <div class="docstring"><pre>Returns the sibling element next to this one or NIL if
it is already last. This excludes comments, text-nodes and the like.</pre></div> </article> </li><li> <a name="PLUMP-DOM:NEXT-SIBLING"> </a> <article id="FUNCTION PLUMP-DOM:NEXT-SIBLING"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ANEXT-SIBLING">NEXT-SIBLING</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHILD</code><code>)</code>  </header> <div class="docstring"><pre>Returns the sibling next to this one or NIL if
it is already the last.</pre></div> </article> </li><li> <a name="PLUMP-DOM:NODE-P"> </a> <article id="FUNCTION PLUMP-DOM:NODE-P"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ANODE-P">NODE-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code>  </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type NODE</pre></div> </article> </li><li> <a name="PLUMP-DOM:PREPEND-CHILD"> </a> <article id="FUNCTION PLUMP-DOM:PREPEND-CHILD"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3APREPEND-CHILD">PREPEND-CHILD</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PARENT CHILD</code><code>)</code>  </header> <div class="docstring"><pre>Prepends the given child onto the parent's child list.
Returns the child.

Note that this operation is costly, see VECTOR-PUSH-EXTEND-FRONT</pre></div> </article> </li><li> <a name="PLUMP-DOM:PREVIOUS-ELEMENT"> </a> <article id="FUNCTION PLUMP-DOM:PREVIOUS-ELEMENT"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3APREVIOUS-ELEMENT">PREVIOUS-ELEMENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHILD</code><code>)</code>  </header> <div class="docstring"><pre>Returns the sibling element next to this one or NIL if
it is already last. This excludes comments, text-nodes and the like.</pre></div> </article> </li><li> <a name="PLUMP-DOM:PREVIOUS-SIBLING"> </a> <article id="FUNCTION PLUMP-DOM:PREVIOUS-SIBLING"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3APREVIOUS-SIBLING">PREVIOUS-SIBLING</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHILD</code><code>)</code>  </header> <div class="docstring"><pre>Returns the sibling before this one or NIL if 
it is already the first.</pre></div> </article> </li><li> <a name="PLUMP-DOM:PROCESSING-INSTRUCTION-P"> </a> <article id="FUNCTION PLUMP-DOM:PROCESSING-INSTRUCTION-P"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3APROCESSING-INSTRUCTION-P">PROCESSING-INSTRUCTION-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code>  </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type PROCESSING-INSTRUCTION</pre></div> </article> </li><li> <a name="PLUMP-DOM:REMOVE-ATTRIBUTE"> </a> <article id="FUNCTION PLUMP-DOM:REMOVE-ATTRIBUTE"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AREMOVE-ATTRIBUTE">REMOVE-ATTRIBUTE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT ATTRIBUTE</code><code>)</code>  </header> <div class="docstring"><pre>Remove the specified attribute if it exists.
Returns NIL.</pre></div> </article> </li><li> <a name="PLUMP-DOM:REMOVE-CHILD"> </a> <article id="FUNCTION PLUMP-DOM:REMOVE-CHILD"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AREMOVE-CHILD">REMOVE-CHILD</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHILD</code><code>)</code>  </header> <div class="docstring"><pre>Removes the child from its parent.
Returns the child.

Note that this operation is potentially very costly.
See <a href="NIL">VECTOR-POP-POSITION</a></pre></div> </article> </li><li> <a name="PLUMP-DOM:RENDER-TEXT"> </a> <article id="FUNCTION PLUMP-DOM:RENDER-TEXT"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ARENDER-TEXT">RENDER-TEXT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE</code><code>)</code>  </header> <div class="docstring"><pre>&quot;Renders&quot; the text of this element and its children.

In effect the text is gathered from the component and all of
its children, but transforming the text in such a way that:
- All ASCII white space (Space, Tab, CR, LF) is converted into spaces.
- There are no consecutive spaces.
- There are no spaces at the beginning or end.

This is somewhat analogous to how the text will be shown to
the user when rendered by a browser. Hence, render-text.</pre></div> </article> </li><li> <a name="PLUMP-DOM:REPLACE-CHILD"> </a> <article id="FUNCTION PLUMP-DOM:REPLACE-CHILD"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AREPLACE-CHILD">REPLACE-CHILD</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OLD-CHILD NEW-CHILD</code><code>)</code>  </header> <div class="docstring"><pre>Replace the old child with a new one.
Returns the old child.</pre></div> </article> </li><li> <a name="PLUMP-DOM:ROOT-P"> </a> <article id="FUNCTION PLUMP-DOM:ROOT-P"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AROOT-P">ROOT-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code>  </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type ROOT</pre></div> </article> </li><li> <a name="PLUMP-DOM:SERIALIZE"> </a> <article id="FUNCTION PLUMP-DOM:SERIALIZE"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ASERIALIZE">SERIALIZE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE &amp;OPTIONAL (STREAM T)</code><code>)</code>  </header> <div class="docstring"><pre>Serializes NODE to STREAM.
STREAM can be a stream, T for *standard-output* or NIL to serialize to string.</pre></div> </article> </li><li> <a name="PLUMP-DOM:SET-ATTRIBUTE"> </a> <article id="FUNCTION PLUMP-DOM:SET-ATTRIBUTE"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ASET-ATTRIBUTE">SET-ATTRIBUTE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT ATTRIBUTE VALUE</code><code>)</code>  </header> <div class="docstring"><pre>Synonymous to (SETF (ATTIBUTE ..) ..)</pre></div> </article> </li><li> <a name="PLUMP-DOM:SIBLING-ELEMENTS"> </a> <article id="FUNCTION PLUMP-DOM:SIBLING-ELEMENTS"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ASIBLING-ELEMENTS">SIBLING-ELEMENTS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHILD</code><code>)</code>  </header> <div class="docstring"><pre>Returns the array of sibling elements of the given child.
Note that this is a copy of the array, modifying it is safe.
This excludes comments, text-nodes and the like.</pre></div> </article> </li><li> <a name="PLUMP-DOM:SIBLINGS"> </a> <article id="FUNCTION PLUMP-DOM:SIBLINGS"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ASIBLINGS">SIBLINGS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHILD</code><code>)</code>  </header> <div class="docstring"><pre>Returns the array of siblings of the given child.
Note that this is a copy of the array, modifying it is safe.</pre></div> </article> </li><li> <a name="PLUMP-DOM:SPLICE"> </a> <article id="FUNCTION PLUMP-DOM:SPLICE"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ASPLICE">SPLICE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT</code><code>)</code>  </header> <div class="docstring"><pre>Splices the contents of element into the position of the element in its parent.
Returns the parent.

Note that this operation is potentially very costly.
See <a href="NIL">ARRAY-SHIFT</a></pre></div> </article> </li><li> <a name="PLUMP-DOM:STRIP"> </a> <article id="FUNCTION PLUMP-DOM:STRIP"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ASTRIP">STRIP</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE</code><code>)</code>  </header> <div class="docstring"><pre>Trim all text-nodes within NODE (at any depth) of leading and trailing whitespace. 
If their TEXT should be an empty string after trimming, remove them.</pre></div> </article> </li><li> <a name="PLUMP-DOM:TEXT-NODE-P"> </a> <article id="FUNCTION PLUMP-DOM:TEXT-NODE-P"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ATEXT-NODE-P">TEXT-NODE-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code>  </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type TEXT-NODE</pre></div> </article> </li><li> <a name="PLUMP-DOM:TEXTUAL-NODE-P"> </a> <article id="FUNCTION PLUMP-DOM:TEXTUAL-NODE-P"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ATEXTUAL-NODE-P">TEXTUAL-NODE-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code>  </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type TEXTUAL-NODE</pre></div> </article> </li><li> <a name="PLUMP-DOM:TRANSLATE-ENTITY"> </a> <article id="FUNCTION PLUMP-DOM:TRANSLATE-ENTITY"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ATRANSLATE-ENTITY">TRANSLATE-ENTITY</a></code></h4> <code class="qualifiers"></code> <code class="arguments">TEXT &amp;KEY (START 0) (END (LENGTH TEXT))</code><code>)</code>  </header> <div class="docstring"><pre>Translates the given entity identifier (a name, #Dec or #xHex) into their respective strings if possible.
Otherwise returns NIL.</pre></div> </article> </li><li> <a name="PLUMP-DOM:TRIM"> </a> <article id="FUNCTION PLUMP-DOM:TRIM"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ATRIM">TRIM</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE</code><code>)</code>  </header> <div class="docstring"><pre>Trim all text-nodes within NODE (at any depth) of leading and trailing whitespace.</pre></div> </article> </li><li> <a name="PLUMP-DOM:WRITE-ENCODE-CHAR"> </a> <article id="FUNCTION PLUMP-DOM:WRITE-ENCODE-CHAR"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AWRITE-ENCODE-CHAR">WRITE-ENCODE-CHAR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHAR STREAM</code><code>)</code>  </header> <div class="docstring"><pre>Write and possibly encode the CHAR to STREAM.
This also properly handles detection of invalid or discouraged XML characters.

The following restarts are available in the case of a faulty character:
  ABORT              Do not output the faulty character at all.
  USE-NEW-CHARACTER  Output a replacement character instead.
  CONTINUE           Continue and output the faulty character anyway.

See <a href="#PLUMP-DOM:INVALID-XML-CHARACTER">INVALID-XML-CHARACTER</a>
See <a href="#PLUMP-DOM:DISCOURAGED-XML-CHARACTER">DISCOURAGED-XML-CHARACTER</a></pre></div> </article> </li><li> <a name="PLUMP-DOM:XML-HEADER-P"> </a> <article id="FUNCTION PLUMP-DOM:XML-HEADER-P"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AXML-HEADER-P">XML-HEADER-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code>  </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type XML-HEADER</pre></div> </article> </li><li> <a name="PLUMP-DOM:CLONE-NODE"> </a> <article id="GENERIC PLUMP-DOM:CLONE-NODE"> <header class="generic"> <span class="type">generic</span>  <code>(</code><h4 class="name"><code><a href="#GENERIC%20PLUMP-DOM%3ACLONE-NODE">CLONE-NODE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE &amp;OPTIONAL DEEP</code><code>)</code>  </header> <div class="docstring"><pre>Clone the given node, creating a new instance with the same contents.
If DEEP is non-NIL, the following applies:
The text of COMMENT and TEXT-NODEs is copied as per COPY-SEQ.
The children of NESTING-NODEs are copied as per (CLONE-CHILDREN CHILD T)</pre></div> </article> </li><li> <a name="PLUMP-DOM:SERIALIZE-OBJECT"> </a> <article id="GENERIC PLUMP-DOM:SERIALIZE-OBJECT"> <header class="generic"> <span class="type">generic</span>  <code>(</code><h4 class="name"><code><a href="#GENERIC%20PLUMP-DOM%3ASERIALIZE-OBJECT">SERIALIZE-OBJECT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE</code><code>)</code>  </header> <div class="docstring"><pre>Serialize the given node and print it to *stream*.</pre></div> </article> </li><li> <a name="PLUMP-DOM:TRAVERSE"> </a> <article id="GENERIC PLUMP-DOM:TRAVERSE"> <header class="generic"> <span class="type">generic</span>  <code>(</code><h4 class="name"><code><a href="#GENERIC%20PLUMP-DOM%3ATRAVERSE">TRAVERSE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE FUNCTION &amp;KEY TEST</code><code>)</code>  </header> <div class="docstring"><pre>Traverse the NODE and all its children recursively,
calling FUNCTION on the current node if calling TEST on the current node
returns a non-NIL value. It is safe to modify the child array of the
parent of each node passed to FUNCTION.

NODE is returned.</pre></div> </article> </li></ul> </li><li class="package"> <h3> <a name="PLUMP-PARSER" href="#PLUMP-PARSER">PLUMP-PARSER</a> <span class="nicknames">(ORG.SHIRAKUMO.PLUMP.PARSER)</span> </h3> <ul><li> <a name="PLUMP-PARSER:*ALL-TAG-DISPATCHERS*"> </a> <article id="SPECIAL PLUMP-PARSER:*ALL-TAG-DISPATCHERS*"> <header class="special"> <span class="type">special</span>  <h4 class="name"><code><a href="#SPECIAL%20PLUMP-PARSER%3A%2AALL-TAG-DISPATCHERS%2A">*ALL-TAG-DISPATCHERS*</a></code></h4>  </header> <div class="docstring"><pre>All defined tag dispatchers</pre></div> </article> </li><li> <a name="PLUMP-PARSER:*HTML-TAGS*"> </a> <article id="SPECIAL PLUMP-PARSER:*HTML-TAGS*"> <header class="special"> <span class="type">special</span>  <h4 class="name"><code><a href="#SPECIAL%20PLUMP-PARSER%3A%2AHTML-TAGS%2A">*HTML-TAGS*</a></code></h4>  </header> <div class="docstring"><pre>List of HTML tag dispatchers</pre></div> </article> </li><li> <a name="PLUMP-PARSER:*ROOT*"> </a> <article id="SPECIAL PLUMP-PARSER:*ROOT*"> <header class="special"> <span class="type">special</span>  <h4 class="name"><code><a href="#SPECIAL%20PLUMP-PARSER%3A%2AROOT%2A">*ROOT*</a></code></h4>  </header> <div class="docstring"><pre>Object containing the current node to set as parent.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:*TAG-DISPATCHERS*"> </a> <article id="SPECIAL PLUMP-PARSER:*TAG-DISPATCHERS*"> <header class="special"> <span class="type">special</span>  <h4 class="name"><code><a href="#SPECIAL%20PLUMP-PARSER%3A%2ATAG-DISPATCHERS%2A">*TAG-DISPATCHERS*</a></code></h4>  </header> <div class="docstring"><pre>Active tag dispatcher functions</pre></div> </article> </li><li> <a name="PLUMP-PARSER:*XML-TAGS*"> </a> <article id="SPECIAL PLUMP-PARSER:*XML-TAGS*"> <header class="special"> <span class="type">special</span>  <h4 class="name"><code><a href="#SPECIAL%20PLUMP-PARSER%3A%2AXML-TAGS%2A">*XML-TAGS*</a></code></h4>  </header> <div class="docstring"><pre>List of XML tag dispatchers</pre></div> </article> </li><li> <a name="PLUMP-PARSER:TAG-DISPATCHER"> </a> <article id="CLASS PLUMP-PARSER:TAG-DISPATCHER"> <header class="class"> <span class="type">class</span>  <h4 class="name"><code><a href="#CLASS%20PLUMP-PARSER%3ATAG-DISPATCHER">TAG-DISPATCHER</a></code></h4>  </header> <div class="docstring"><pre>Encapsulates the processing for a given tag.

See <a href="NIL">TAG-DISPATCHER-NAME</a>
See <a href="NIL">TAG-DISPATCHER-TEST</a>
See <a href="NIL">TAG-DISPATCHER-PARSER</a>
See <a href="NIL">TAG-DISPATCHER-PRINTER</a></pre></div> </article> </li><li> <a name="PLUMP-PARSER:PROCESSING-PARSER"> </a> <article id="ACCESSOR PLUMP-PARSER:PROCESSING-PARSER"> <header class="accessor"> <span class="type">accessor</span>  <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20PLUMP-PARSER%3APROCESSING-PARSER">PROCESSING-PARSER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PROCESS-NAME</code><code>)</code>  </header> <div class="docstring"><pre>Return the processing-parser function for PROCESS-NAME. SETF-able.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:READ-ATTRIBUTE"> </a> <article id="FUNCTION PLUMP-PARSER:READ-ATTRIBUTE"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-PARSER%3AREAD-ATTRIBUTE">READ-ATTRIBUTE</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code>  </header> <div class="docstring"><pre>Reads an attribute and returns it as a key value cons.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:READ-ATTRIBUTE-NAME"> </a> <article id="FUNCTION PLUMP-PARSER:READ-ATTRIBUTE-NAME"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-PARSER%3AREAD-ATTRIBUTE-NAME">READ-ATTRIBUTE-NAME</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code>  </header> <div class="docstring"><pre>Reads an attribute name.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:READ-ATTRIBUTE-VALUE"> </a> <article id="FUNCTION PLUMP-PARSER:READ-ATTRIBUTE-VALUE"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-PARSER%3AREAD-ATTRIBUTE-VALUE">READ-ATTRIBUTE-VALUE</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code>  </header> <div class="docstring"><pre>Reads an attribute value, either enclosed in quotation marks or until a space or tag end.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:READ-ATTRIBUTES"> </a> <article id="FUNCTION PLUMP-PARSER:READ-ATTRIBUTES"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-PARSER%3AREAD-ATTRIBUTES">READ-ATTRIBUTES</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code>  </header> <div class="docstring"><pre>Reads as many attributes as possible from a tag and returns them as an attribute map.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:READ-CHILDREN"> </a> <article id="FUNCTION PLUMP-PARSER:READ-CHILDREN"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-PARSER%3AREAD-CHILDREN">READ-CHILDREN</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code>  </header> <div class="docstring"><pre>Read all children of the current *root* until the closing tag for *root* is encountered.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:READ-NAME"> </a> <article id="FUNCTION PLUMP-PARSER:READ-NAME"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-PARSER%3AREAD-NAME">READ-NAME</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code>  </header> <div class="docstring"><pre>Reads and returns a tag name.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:READ-ROOT"> </a> <article id="FUNCTION PLUMP-PARSER:READ-ROOT"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-PARSER%3AREAD-ROOT">READ-ROOT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">&amp;OPTIONAL (ROOT (MAKE-ROOT))</code><code>)</code>  </header> <div class="docstring"><pre>Creates a root element and reads nodes into it.
Optionally uses the specified root to append child nodes to.
Returns the root.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:READ-STANDARD-TAG"> </a> <article id="FUNCTION PLUMP-PARSER:READ-STANDARD-TAG"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-PARSER%3AREAD-STANDARD-TAG">READ-STANDARD-TAG</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NAME</code><code>)</code>  </header> <div class="docstring"><pre>Reads an arbitrary tag and returns it.
This recurses with READ-CHILDREN.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:READ-TAG"> </a> <article id="FUNCTION PLUMP-PARSER:READ-TAG"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-PARSER%3AREAD-TAG">READ-TAG</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code>  </header> <div class="docstring"><pre>Attempts to read a tag and dispatches or defaults to READ-STANDARD-TAG.
Returns the completed node if one can be read.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:READ-TAG-CONTENTS"> </a> <article id="FUNCTION PLUMP-PARSER:READ-TAG-CONTENTS"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-PARSER%3AREAD-TAG-CONTENTS">READ-TAG-CONTENTS</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code>  </header> <div class="docstring"><pre>Reads and returns all tag contents. 
E.g. &lt;foo bar baz&gt; =&gt; bar baz</pre></div> </article> </li><li> <a name="PLUMP-PARSER:READ-TEXT"> </a> <article id="FUNCTION PLUMP-PARSER:READ-TEXT"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-PARSER%3AREAD-TEXT">READ-TEXT</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code>  </header> <div class="docstring"><pre>Reads and returns a text-node.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:REMOVE-PROCESSING-PARSER"> </a> <article id="FUNCTION PLUMP-PARSER:REMOVE-PROCESSING-PARSER"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-PARSER%3AREMOVE-PROCESSING-PARSER">REMOVE-PROCESSING-PARSER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PROCESS-NAME</code><code>)</code>  </header> <div class="docstring"><pre>Remove the processing-parser for PROCESS-NAME.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:REMOVE-TAG-DISPATCHER"> </a> <article id="FUNCTION PLUMP-PARSER:REMOVE-TAG-DISPATCHER"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-PARSER%3AREMOVE-TAG-DISPATCHER">REMOVE-TAG-DISPATCHER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NAME &amp;OPTIONAL (LIST '*ALL-TAG-DISPATCHERS*)</code><code>)</code>  </header> <div class="docstring"><pre>Removes the tag-dispatcher of the given name from the list.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:SLURP-STREAM"> </a> <article id="FUNCTION PLUMP-PARSER:SLURP-STREAM"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-PARSER%3ASLURP-STREAM">SLURP-STREAM</a></code></h4> <code class="qualifiers"></code> <code class="arguments">STREAM</code><code>)</code>  </header> <div class="docstring"><pre>Quickly slurps the stream's contents into an array with fill pointer.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:TAG-DISPATCHER"> </a> <article id="FUNCTION PLUMP-PARSER:TAG-DISPATCHER"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-PARSER%3ATAG-DISPATCHER">TAG-DISPATCHER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NAME &amp;OPTIONAL (LIST *ALL-TAG-DISPATCHERS*)</code><code>)</code>  </header> <div class="docstring"><pre>Accessor to the tag-dispatcher of the given name.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:PARSE"> </a> <article id="GENERIC PLUMP-PARSER:PARSE"> <header class="generic"> <span class="type">generic</span>  <code>(</code><h4 class="name"><code><a href="#GENERIC%20PLUMP-PARSER%3APARSE">PARSE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">INPUT &amp;KEY ROOT</code><code>)</code>  </header> <div class="docstring"><pre>Parses the given input into a DOM representation.
By default, methods for STRING, PATHNAME and STREAM are defined.
If supplied, the given root is used to append children to as per READ-ROOT.
Returns the root.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:DEFINE-FULLTEXT-ELEMENT"> </a> <article id="MACRO PLUMP-PARSER:DEFINE-FULLTEXT-ELEMENT"> <header class="macro"> <span class="type">macro</span>  <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP-PARSER%3ADEFINE-FULLTEXT-ELEMENT">DEFINE-FULLTEXT-ELEMENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">TAG &amp;REST LISTS</code><code>)</code>  </header> <div class="docstring"><pre>Defines an element to be read as a full-text element.
This means that it cannot contain any child-nodes and everything up until its closing
tag is used as its text.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:DEFINE-PROCESSING-PARSER"> </a> <article id="MACRO PLUMP-PARSER:DEFINE-PROCESSING-PARSER"> <header class="macro"> <span class="type">macro</span>  <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP-PARSER%3ADEFINE-PROCESSING-PARSER">DEFINE-PROCESSING-PARSER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PROCESS-NAME NIL &amp;BODY BODY</code><code>)</code>  </header> <div class="docstring"><pre>Defines a new processing-instruction parser. 
It is invoked if a processing-instruction (&lt;?) with PROCESS-NAME is encountered.
The lexer will be at the point straight after reading in the PROCESS-NAME.
Expected return value is a string to use as the processing-instructions' TEXT.
The closing tag (?&gt;) should NOT be consumed by a processing-parser.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:DEFINE-SELF-CLOSING-ELEMENT"> </a> <article id="MACRO PLUMP-PARSER:DEFINE-SELF-CLOSING-ELEMENT"> <header class="macro"> <span class="type">macro</span>  <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP-PARSER%3ADEFINE-SELF-CLOSING-ELEMENT">DEFINE-SELF-CLOSING-ELEMENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">TAG &amp;REST LISTS</code><code>)</code>  </header> <div class="docstring"><pre>Defines an element that does not need to be closed with /&gt; and cannot contain child nodes.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:DEFINE-TAG-DISPATCHER"> </a> <article id="MACRO PLUMP-PARSER:DEFINE-TAG-DISPATCHER"> <header class="macro"> <span class="type">macro</span>  <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP-PARSER%3ADEFINE-TAG-DISPATCHER">DEFINE-TAG-DISPATCHER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">(NAME &amp;REST LISTS) (TAGVAR) &amp;BODY BODY</code><code>)</code>  </header> <div class="docstring"><pre>Defines a new tag dispatcher. It is invoked if TEST-FORM passes.

NAME      --- Name to discern the dispatcher with.
LISTS     --- Symbols of lists to which the dispatcher should be added.
TAGVAR    --- Symbol bound to the tag name.
BODY      --- Body forms describing the test to match the tag.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:DEFINE-TAG-PARSER"> </a> <article id="MACRO PLUMP-PARSER:DEFINE-TAG-PARSER"> <header class="macro"> <span class="type">macro</span>  <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP-PARSER%3ADEFINE-TAG-PARSER">DEFINE-TAG-PARSER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NAME (TAGVAR) &amp;BODY BODY</code><code>)</code>  </header> <div class="docstring"><pre>Defines the parser function for a tag dispatcher.

NAME    --- The name of the tag dispatcher. If one with this name 
            cannot be found, an error is signalled.
TAGVAR  --- Symbol bound to the tag name.
BODY    --- Body forms describing the tag parsing behaviour.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:DEFINE-TAG-PRINTER"> </a> <article id="MACRO PLUMP-PARSER:DEFINE-TAG-PRINTER"> <header class="macro"> <span class="type">macro</span>  <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP-PARSER%3ADEFINE-TAG-PRINTER">DEFINE-TAG-PRINTER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NAME (NODEVAR) &amp;BODY BODY</code><code>)</code>  </header> <div class="docstring"><pre>Defines the printer function for a tag dispatcher.

NAME    --- The name of the tag dispatcher. If one with this name 
            cannot be found, an error is signalled.
TAGVAR  --- Symbol bound to the tag name.
BODY    --- Body forms describing the printing behaviour. Write to
            the stream bound to PLUMP-DOM:*STREAM*.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:DO-TAG-PARSERS"> </a> <article id="MACRO PLUMP-PARSER:DO-TAG-PARSERS"> <header class="macro"> <span class="type">macro</span>  <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP-PARSER%3ADO-TAG-PARSERS">DO-TAG-PARSERS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">(TEST PARSER &amp;OPTIONAL RESULT-FORM) &amp;BODY BODY</code><code>)</code>  </header> <div class="docstring"><pre>Iterates over the current *TAG-DISPATCHERS*, binding the TEST and PARSER functions.
Returns RESULT-FORM's evaluated value.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:DO-TAG-PRINTERS"> </a> <article id="MACRO PLUMP-PARSER:DO-TAG-PRINTERS"> <header class="macro"> <span class="type">macro</span>  <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP-PARSER%3ADO-TAG-PRINTERS">DO-TAG-PRINTERS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">(TEST PRINTER &amp;OPTIONAL RESULT-FORM) &amp;BODY BODY</code><code>)</code>  </header> <div class="docstring"><pre>Iterates over the current *TAG-DISPATCHERS*, binding the TEST and PRINTER functions.
Returns RESULT-FORM's evaluated value.</pre></div> </article> </li></ul> </li><li class="package"> <h3> <a name="PLUMP" href="#PLUMP">PLUMP</a> <span class="nicknames">(ORG.SHIRAKUMO.PLUMP)</span> </h3> <ul><li> <a name="PLUMP:*ALL-TAG-DISPATCHERS*"> </a> <article id="SPECIAL PLUMP:*ALL-TAG-DISPATCHERS*"> <header class="special"> <span class="type">special</span>  <h4 class="name"><code><a href="#SPECIAL%20PLUMP%3A%2AALL-TAG-DISPATCHERS%2A">*ALL-TAG-DISPATCHERS*</a></code></h4>  </header> <div class="docstring"><pre>All defined tag dispatchers</pre></div> </article> </li><li> <a name="PLUMP:*ENTITY-MAP*"> </a> <article id="SPECIAL PLUMP:*ENTITY-MAP*"> <header class="special"> <span class="type">special</span>  <h4 class="name"><code><a href="#SPECIAL%20PLUMP%3A%2AENTITY-MAP%2A">*ENTITY-MAP*</a></code></h4>  </header> <div class="docstring"><pre>String hash-table containing the entity names and mapping them to their respective characters.</pre></div> </article> </li><li> <a name="PLUMP:*HTML-TAGS*"> </a> <article id="SPECIAL PLUMP:*HTML-TAGS*"> <header class="special"> <span class="type">special</span>  <h4 class="name"><code><a href="#SPECIAL%20PLUMP%3A%2AHTML-TAGS%2A">*HTML-TAGS*</a></code></h4>  </header> <div class="docstring"><pre>List of HTML tag dispatchers</pre></div> </article> </li><li> <a name="PLUMP:*INDEX*"> </a> <article id="SPECIAL PLUMP:*INDEX*"> <header class="special"> <span class="type">special</span>  <h4 class="name"><code><a href="#SPECIAL%20PLUMP%3A%2AINDEX%2A">*INDEX*</a></code></h4>  </header> <div class="docstring"><pre>Set to the current reading index.</pre></div> </article> </li><li> <a name="PLUMP:*LENGTH*"> </a> <article id="SPECIAL PLUMP:*LENGTH*"> <header class="special"> <span class="type">special</span>  <h4 class="name"><code><a href="#SPECIAL%20PLUMP%3A%2ALENGTH%2A">*LENGTH*</a></code></h4>  </header> <div class="docstring"><pre>Set to the length of the string for bounds checking.</pre></div> </article> </li><li> <a name="PLUMP:*ROOT*"> </a> <article id="SPECIAL PLUMP:*ROOT*"> <header class="special"> <span class="type">special</span>  <h4 class="name"><code><a href="#SPECIAL%20PLUMP%3A%2AROOT%2A">*ROOT*</a></code></h4>  </header> <div class="docstring"><pre>Object containing the current node to set as parent.</pre></div> </article> </li><li> <a name="PLUMP:*STREAM*"> </a> <article id="SPECIAL PLUMP:*STREAM*"> <header class="special"> <span class="type">special</span>  <h4 class="name"><code><a href="#SPECIAL%20PLUMP%3A%2ASTREAM%2A">*STREAM*</a></code></h4>  </header> <div class="docstring"><pre>The stream to serialize to during SERIALIZE-OBJECT.</pre></div> </article> </li><li> <a name="PLUMP:*STRING*"> </a> <article id="SPECIAL PLUMP:*STRING*"> <header class="special"> <span class="type">special</span>  <h4 class="name"><code><a href="#SPECIAL%20PLUMP%3A%2ASTRING%2A">*STRING*</a></code></h4>  </header> <div class="docstring"><pre>Contains the current string to lex.</pre></div> </article> </li><li> <a name="PLUMP:*TAG-DISPATCHERS*"> </a> <article id="SPECIAL PLUMP:*TAG-DISPATCHERS*"> <header class="special"> <span class="type">special</span>  <h4 class="name"><code><a href="#SPECIAL%20PLUMP%3A%2ATAG-DISPATCHERS%2A">*TAG-DISPATCHERS*</a></code></h4>  </header> <div class="docstring"><pre>Active tag dispatcher functions</pre></div> </article> </li><li> <a name="PLUMP:*XML-TAGS*"> </a> <article id="SPECIAL PLUMP:*XML-TAGS*"> <header class="special"> <span class="type">special</span>  <h4 class="name"><code><a href="#SPECIAL%20PLUMP%3A%2AXML-TAGS%2A">*XML-TAGS*</a></code></h4>  </header> <div class="docstring"><pre>List of XML tag dispatchers</pre></div> </article> </li><li> <a name="PLUMP:CDATA"> </a> <article id="CLASS PLUMP:CDATA"> <header class="class"> <span class="type">class</span>  <h4 class="name"><code><a href="#CLASS%20PLUMP%3ACDATA">CDATA</a></code></h4>  </header> <div class="docstring"><pre>XML CDATA section node.</pre></div> </article> </li><li> <a name="PLUMP:CHILD-NODE"> </a> <article id="CLASS PLUMP:CHILD-NODE"> <header class="class"> <span class="type">class</span>  <h4 class="name"><code><a href="#CLASS%20PLUMP%3ACHILD-NODE">CHILD-NODE</a></code></h4>  </header> <div class="docstring"><pre>Node class that is a child and thus has a parent.</pre></div> </article> </li><li> <a name="PLUMP:COMMENT"> </a> <article id="CLASS PLUMP:COMMENT"> <header class="class"> <span class="type">class</span>  <h4 class="name"><code><a href="#CLASS%20PLUMP%3ACOMMENT">COMMENT</a></code></h4>  </header> <div class="docstring"><pre>Comment node that can only contain a single comment string.</pre></div> </article> </li><li> <a name="PLUMP:DOCTYPE"> </a> <article id="CLASS PLUMP:DOCTYPE"> <header class="class"> <span class="type">class</span>  <h4 class="name"><code><a href="#CLASS%20PLUMP%3ADOCTYPE">DOCTYPE</a></code></h4>  </header> <div class="docstring"><pre>Special DOM node for the doctype declaration.</pre></div> </article> </li><li> <a name="PLUMP:ELEMENT"> </a> <article id="CLASS PLUMP:ELEMENT"> <header class="class"> <span class="type">class</span>  <h4 class="name"><code><a href="#CLASS%20PLUMP%3AELEMENT">ELEMENT</a></code></h4>  </header> <div class="docstring"><pre>Standard DOM element/block including attributes, tag-name, parent and children.</pre></div> </article> </li><li> <a name="PLUMP:FULLTEXT-ELEMENT"> </a> <article id="CLASS PLUMP:FULLTEXT-ELEMENT"> <header class="class"> <span class="type">class</span>  <h4 class="name"><code><a href="#CLASS%20PLUMP%3AFULLTEXT-ELEMENT">FULLTEXT-ELEMENT</a></code></h4>  </header> <div class="docstring"><pre>Special DOM element that contains full, un-entitied text like SCRIPT and STYLE.</pre></div> </article> </li><li> <a name="PLUMP:NESTING-NODE"> </a> <article id="CLASS PLUMP:NESTING-NODE"> <header class="class"> <span class="type">class</span>  <h4 class="name"><code><a href="#CLASS%20PLUMP%3ANESTING-NODE">NESTING-NODE</a></code></h4>  </header> <div class="docstring"><pre>Node class that can contain child nodes.</pre></div> </article> </li><li> <a name="PLUMP:NODE"> </a> <article id="CLASS PLUMP:NODE"> <header class="class"> <span class="type">class</span>  <h4 class="name"><code><a href="#CLASS%20PLUMP%3ANODE">NODE</a></code></h4>  </header> <div class="docstring"><pre>Base DOM node class.</pre></div> </article> </li><li> <a name="PLUMP:PROCESSING-INSTRUCTION"> </a> <article id="CLASS PLUMP:PROCESSING-INSTRUCTION"> <header class="class"> <span class="type">class</span>  <h4 class="name"><code><a href="#CLASS%20PLUMP%3APROCESSING-INSTRUCTION">PROCESSING-INSTRUCTION</a></code></h4>  </header> <div class="docstring"><pre>XML processing instruction node.</pre></div> </article> </li><li> <a name="PLUMP:ROOT"> </a> <article id="CLASS PLUMP:ROOT"> <header class="class"> <span class="type">class</span>  <h4 class="name"><code><a href="#CLASS%20PLUMP%3AROOT">ROOT</a></code></h4>  </header> <div class="docstring"><pre>Root DOM node, practically equivalent to a &quot;document&quot;.</pre></div> </article> </li><li> <a name="PLUMP:TAG-DISPATCHER"> </a> <article id="CLASS PLUMP:TAG-DISPATCHER"> <header class="class"> <span class="type">class</span>  <h4 class="name"><code><a href="#CLASS%20PLUMP%3ATAG-DISPATCHER">TAG-DISPATCHER</a></code></h4>  </header> <div class="docstring"><pre>Encapsulates the processing for a given tag.

See <a href="NIL">TAG-DISPATCHER-NAME</a>
See <a href="NIL">TAG-DISPATCHER-TEST</a>
See <a href="NIL">TAG-DISPATCHER-PARSER</a>
See <a href="NIL">TAG-DISPATCHER-PRINTER</a></pre></div> </article> </li><li> <a name="PLUMP:TEXT-NODE"> </a> <article id="CLASS PLUMP:TEXT-NODE"> <header class="class"> <span class="type">class</span>  <h4 class="name"><code><a href="#CLASS%20PLUMP%3ATEXT-NODE">TEXT-NODE</a></code></h4>  </header> <div class="docstring"><pre>Text node that can only contain a single text string.</pre></div> </article> </li><li> <a name="PLUMP:TEXTUAL-NODE"> </a> <article id="CLASS PLUMP:TEXTUAL-NODE"> <header class="class"> <span class="type">class</span>  <h4 class="name"><code><a href="#CLASS%20PLUMP%3ATEXTUAL-NODE">TEXTUAL-NODE</a></code></h4>  </header> <div class="docstring"><pre>Node class that represents a textual node and thus contains a TEXT field.</pre></div> </article> </li><li> <a name="PLUMP:XML-HEADER"> </a> <article id="CLASS PLUMP:XML-HEADER"> <header class="class"> <span class="type">class</span>  <h4 class="name"><code><a href="#CLASS%20PLUMP%3AXML-HEADER">XML-HEADER</a></code></h4>  </header> <div class="docstring"><pre>XML header element</pre></div> </article> </li><li> <a name="PLUMP:DISCOURAGED-XML-CHARACTER"> </a> <article id="CONDITION PLUMP:DISCOURAGED-XML-CHARACTER"> <header class="condition"> <span class="type">condition</span>  <h4 class="name"><code><a href="#CONDITION%20PLUMP%3ADISCOURAGED-XML-CHARACTER">DISCOURAGED-XML-CHARACTER</a></code></h4>  </header> <div class="docstring"><pre>Warning signalled when a discouraged XML character is encountered during WRITE-ENCODE-CHAR.</pre></div> </article> </li><li> <a name="PLUMP:INVALID-XML-CHARACTER"> </a> <article id="CONDITION PLUMP:INVALID-XML-CHARACTER"> <header class="condition"> <span class="type">condition</span>  <h4 class="name"><code><a href="#CONDITION%20PLUMP%3AINVALID-XML-CHARACTER">INVALID-XML-CHARACTER</a></code></h4>  </header> <div class="docstring"><pre>Error signalled when an invalid XML character is encountered during WRITE-ENCODE-CHAR.</pre></div> </article> </li><li> <a name="PLUMP:ATTRIBUTE"> </a> <article id="ACCESSOR PLUMP:ATTRIBUTE"> <header class="accessor"> <span class="type">accessor</span>  <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20PLUMP%3AATTRIBUTE">ATTRIBUTE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT ATTRIBUTE</code><code>)</code>  </header> <div class="docstring"><pre>Returns the asked attribute from the element
or NIL. If the attribute could not be found, the
second return value is set to NIL.</pre></div> </article> </li><li> <a name="PLUMP:ATTRIBUTES"> </a> <article id="ACCESSOR PLUMP:ATTRIBUTES"> <header class="accessor"> <span class="type">accessor</span>  <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20PLUMP%3AATTRIBUTES">ATTRIBUTES</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code>  </header> <div class="docstring"><pre>Returns an EQUALP hash-table of the element's attributes.</pre></div> </article> </li><li> <a name="PLUMP:CHILDREN"> </a> <article id="ACCESSOR PLUMP:CHILDREN"> <header class="accessor"> <span class="type">accessor</span>  <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20PLUMP%3ACHILDREN">CHILDREN</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code>  </header> <div class="docstring"><pre>Returns a vector of child-nodes that are contained within the node.</pre></div> </article> </li><li> <a name="PLUMP:DOCTYPE"> </a> <article id="ACCESSOR PLUMP:DOCTYPE"> <header class="accessor"> <span class="type">accessor</span>  <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20PLUMP%3ADOCTYPE">DOCTYPE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code>  </header> <div class="docstring"><pre>Returns the doctype node's actual doctype string.</pre></div> </article> </li><li> <a name="PLUMP:FAULTY-CHAR"> </a> <article id="ACCESSOR PLUMP:FAULTY-CHAR"> <header class="accessor"> <span class="type">accessor</span>  <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20PLUMP%3AFAULTY-CHAR">FAULTY-CHAR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CONDITION</code><code>)</code>  </header> <div class="docstring"><pre>Returns the faulty char that caused the signal.</pre></div> </article> </li><li> <a name="PLUMP:PARENT"> </a> <article id="ACCESSOR PLUMP:PARENT"> <header class="accessor"> <span class="type">accessor</span>  <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20PLUMP%3APARENT">PARENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code>  </header> <div class="docstring"><pre>Returns the node's parent that should contain this element as a child.</pre></div> </article> </li><li> <a name="PLUMP:PROCESSING-PARSER"> </a> <article id="ACCESSOR PLUMP:PROCESSING-PARSER"> <header class="accessor"> <span class="type">accessor</span>  <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20PLUMP%3APROCESSING-PARSER">PROCESSING-PARSER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PROCESS-NAME</code><code>)</code>  </header> <div class="docstring"><pre>Return the processing-parser function for PROCESS-NAME. SETF-able.</pre></div> </article> </li><li> <a name="PLUMP:TAG-NAME"> </a> <article id="ACCESSOR PLUMP:TAG-NAME"> <header class="accessor"> <span class="type">accessor</span>  <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20PLUMP%3ATAG-NAME">TAG-NAME</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code>  </header> <div class="docstring"><pre>Returns the element's tag name.</pre></div> </article> </li><li> <a name="PLUMP:TEXT"> </a> <article id="ACCESSOR PLUMP:TEXT"> <header class="accessor"> <span class="type">accessor</span>  <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20PLUMP%3ATEXT">TEXT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code>  </header> <div class="docstring"><pre>Returns the node's textual content.</pre></div> </article> </li><li> <a name="PLUMP:ADVANCE"> </a> <article id="FUNCTION PLUMP:ADVANCE"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AADVANCE">ADVANCE</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code>  </header> <div class="docstring"><pre>Skips a chracter if possible.
Returns the new index or NIL.</pre></div> </article> </li><li> <a name="PLUMP:ADVANCE-N"> </a> <article id="FUNCTION PLUMP:ADVANCE-N"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AADVANCE-N">ADVANCE-N</a></code></h4> <code class="qualifiers"></code> <code class="arguments">N</code><code>)</code>  </header> <div class="docstring"><pre>Advances by N characters if possible.
Returns the new *INDEX*.</pre></div> </article> </li><li> <a name="PLUMP:ALLOWED-CHAR-P"> </a> <article id="FUNCTION PLUMP:ALLOWED-CHAR-P"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AALLOWED-CHAR-P">ALLOWED-CHAR-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHAR</code><code>)</code>  </header> <div class="docstring"><pre>Returns T if the character is a permitted XML character.</pre></div> </article> </li><li> <a name="PLUMP:APPEND-CHILD"> </a> <article id="FUNCTION PLUMP:APPEND-CHILD"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AAPPEND-CHILD">APPEND-CHILD</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PARENT CHILD</code><code>)</code>  </header> <div class="docstring"><pre>Appends the given child onto the parent's child list.
Returns the child.</pre></div> </article> </li><li> <a name="PLUMP:CDATA-P"> </a> <article id="FUNCTION PLUMP:CDATA-P"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ACDATA-P">CDATA-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code>  </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type CDATA</pre></div> </article> </li><li> <a name="PLUMP:CHILD-ELEMENTS"> </a> <article id="FUNCTION PLUMP:CHILD-ELEMENTS"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ACHILD-ELEMENTS">CHILD-ELEMENTS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NESTING-NODE</code><code>)</code>  </header> <div class="docstring"><pre>Returns a new vector of children of the given node, filtered to elements.</pre></div> </article> </li><li> <a name="PLUMP:CHILD-NODE-P"> </a> <article id="FUNCTION PLUMP:CHILD-NODE-P"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ACHILD-NODE-P">CHILD-NODE-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code>  </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type CHILD-NODE</pre></div> </article> </li><li> <a name="PLUMP:CHILD-POSITION"> </a> <article id="FUNCTION PLUMP:CHILD-POSITION"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ACHILD-POSITION">CHILD-POSITION</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHILD</code><code>)</code>  </header> <div class="docstring"><pre>Returns the index of the child within its parent.</pre></div> </article> </li><li> <a name="PLUMP:CLEAR"> </a> <article id="FUNCTION PLUMP:CLEAR"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ACLEAR">CLEAR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NESTING-NODE</code><code>)</code>  </header> <div class="docstring"><pre>Clears all children from the node.

Noe that the PARENT of all child elements is set to NIL.</pre></div> </article> </li><li> <a name="PLUMP:CLONE-ATTRIBUTES"> </a> <article id="FUNCTION PLUMP:CLONE-ATTRIBUTES"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ACLONE-ATTRIBUTES">CLONE-ATTRIBUTES</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE</code><code>)</code>  </header> <div class="docstring"><pre>Clone the attribute map.
Note that keys and values are NOT copied/cloned.</pre></div> </article> </li><li> <a name="PLUMP:CLONE-CHILDREN"> </a> <article id="FUNCTION PLUMP:CLONE-CHILDREN"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ACLONE-CHILDREN">CLONE-CHILDREN</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE &amp;OPTIONAL DEEP NEW-PARENT</code><code>)</code>  </header> <div class="docstring"><pre>Clone the array of children.
If DEEP is non-NIL, each child is cloned as per (CLONE-NODE NODE T).
When copying deeply, you can also pass a NEW-PARENT to set on each child.</pre></div> </article> </li><li> <a name="PLUMP:COMMENT-P"> </a> <article id="FUNCTION PLUMP:COMMENT-P"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ACOMMENT-P">COMMENT-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code>  </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type COMMENT</pre></div> </article> </li><li> <a name="PLUMP:CONSUME"> </a> <article id="FUNCTION PLUMP:CONSUME"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ACONSUME">CONSUME</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code>  </header> <div class="docstring"><pre>Consumes a single character if possible and returns it.
Otherwise returns NIL.</pre></div> </article> </li><li> <a name="PLUMP:CONSUME-UNTIL"> </a> <article id="FUNCTION PLUMP:CONSUME-UNTIL"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ACONSUME-UNTIL">CONSUME-UNTIL</a></code></h4> <code class="qualifiers"></code> <code class="arguments">MATCHER</code><code>)</code>  </header> <div class="docstring"><pre>Consumes until the provided matcher function returns positively.
Returns the substring that was consumed.</pre></div> </article> </li><li> <a name="PLUMP:DECODE-ENTITIES"> </a> <article id="FUNCTION PLUMP:DECODE-ENTITIES"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ADECODE-ENTITIES">DECODE-ENTITIES</a></code></h4> <code class="qualifiers"></code> <code class="arguments">TEXT &amp;OPTIONAL REMOVE-INVALID</code><code>)</code>  </header> <div class="docstring"><pre>Translates all entities in the text into their character counterparts if possible.
If an entity does not match, it is left in place unless REMOVE-INVALID is non-NIL.</pre></div> </article> </li><li> <a name="PLUMP:DISCOURAGED-CHAR-P"> </a> <article id="FUNCTION PLUMP:DISCOURAGED-CHAR-P"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ADISCOURAGED-CHAR-P">DISCOURAGED-CHAR-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHAR</code><code>)</code>  </header> <div class="docstring"><pre>Returns T if the character is a discouraged XML character.</pre></div> </article> </li><li> <a name="PLUMP:DOCTYPE-P"> </a> <article id="FUNCTION PLUMP:DOCTYPE-P"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ADOCTYPE-P">DOCTYPE-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code>  </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type DOCTYPE</pre></div> </article> </li><li> <a name="PLUMP:ELEMENT-P"> </a> <article id="FUNCTION PLUMP:ELEMENT-P"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AELEMENT-P">ELEMENT-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code>  </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type ELEMENT</pre></div> </article> </li><li> <a name="PLUMP:ELEMENT-POSITION"> </a> <article id="FUNCTION PLUMP:ELEMENT-POSITION"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AELEMENT-POSITION">ELEMENT-POSITION</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHILD</code><code>)</code>  </header> <div class="docstring"><pre>Returns the index of the child within its parent, counting only elements.
This excludes comments, text-nodes and the like.</pre></div> </article> </li><li> <a name="PLUMP:ENCODE-ENTITIES"> </a> <article id="FUNCTION PLUMP:ENCODE-ENTITIES"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AENCODE-ENTITIES">ENCODE-ENTITIES</a></code></h4> <code class="qualifiers"></code> <code class="arguments">TEXT &amp;OPTIONAL STREAM</code><code>)</code>  </header> <div class="docstring"><pre>Encodes the characters &lt; &gt; &amp; &quot; with their XML entity equivalents.

If no STREAM is given, it encodes to a new string.</pre></div> </article> </li><li> <a name="PLUMP:ENSURE-ATTRIBUTE-MAP"> </a> <article id="FUNCTION PLUMP:ENSURE-ATTRIBUTE-MAP"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AENSURE-ATTRIBUTE-MAP">ENSURE-ATTRIBUTE-MAP</a></code></h4> <code class="qualifiers"></code> <code class="arguments">TABLE</code><code>)</code>  </header> <div class="docstring"><pre>Ensures that the TABLE is suitable as an attribute-map.
If it is not, the table is copied into a proper attribute-map.</pre></div> </article> </li><li> <a name="PLUMP:ENSURE-CHILD-ARRAY"> </a> <article id="FUNCTION PLUMP:ENSURE-CHILD-ARRAY"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AENSURE-CHILD-ARRAY">ENSURE-CHILD-ARRAY</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ARRAY</code><code>)</code>  </header> <div class="docstring"><pre>If the ARRAY is suitable as a child-array, it is returned.
Otherwise the array's elements are copied over into a proper
child-array.</pre></div> </article> </li><li> <a name="PLUMP:FAMILY"> </a> <article id="FUNCTION PLUMP:FAMILY"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AFAMILY">FAMILY</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHILD</code><code>)</code>  </header> <div class="docstring"><pre>Returns the direct array of children of the parent of the given child.
Note that modifying this array directly modifies that of the parent.</pre></div> </article> </li><li> <a name="PLUMP:FAMILY-ELEMENTS"> </a> <article id="FUNCTION PLUMP:FAMILY-ELEMENTS"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AFAMILY-ELEMENTS">FAMILY-ELEMENTS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHILD</code><code>)</code>  </header> <div class="docstring"><pre>Returns the direct array of children elements of the parent of the given child.
Note that this is a copy of the array, modifying it is safe.
This excludes comments, text-nodes and the like.</pre></div> </article> </li><li> <a name="PLUMP:FIRST-CHILD"> </a> <article id="FUNCTION PLUMP:FIRST-CHILD"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AFIRST-CHILD">FIRST-CHILD</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT</code><code>)</code>  </header> <div class="docstring"><pre>Returns the first child within the parent or NIL
if the parent is empty.</pre></div> </article> </li><li> <a name="PLUMP:FIRST-ELEMENT"> </a> <article id="FUNCTION PLUMP:FIRST-ELEMENT"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AFIRST-ELEMENT">FIRST-ELEMENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT</code><code>)</code>  </header> <div class="docstring"><pre>Returns the first child element within the parent or NIL
if the parent is empty. This excludes comments, text-nodes and the like.</pre></div> </article> </li><li> <a name="PLUMP:FULLTEXT-ELEMENT-P"> </a> <article id="FUNCTION PLUMP:FULLTEXT-ELEMENT-P"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AFULLTEXT-ELEMENT-P">FULLTEXT-ELEMENT-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code>  </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type FULLTEXT-ELEMENT</pre></div> </article> </li><li> <a name="PLUMP:GET-ATTRIBUTE"> </a> <article id="FUNCTION PLUMP:GET-ATTRIBUTE"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AGET-ATTRIBUTE">GET-ATTRIBUTE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT ATTRIBUTE</code><code>)</code>  </header> <div class="docstring"><pre>Synonymous to ATTRIBUTE.</pre></div> </article> </li><li> <a name="PLUMP:GET-ELEMENT-BY-ID"> </a> <article id="FUNCTION PLUMP:GET-ELEMENT-BY-ID"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AGET-ELEMENT-BY-ID">GET-ELEMENT-BY-ID</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE ID</code><code>)</code>  </header> <div class="docstring"><pre>Searches the given node and returns the first
node at arbitrary depth that matches the given ID
attribute.</pre></div> </article> </li><li> <a name="PLUMP:GET-ELEMENTS-BY-TAG-NAME"> </a> <article id="FUNCTION PLUMP:GET-ELEMENTS-BY-TAG-NAME"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AGET-ELEMENTS-BY-TAG-NAME">GET-ELEMENTS-BY-TAG-NAME</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE TAG</code><code>)</code>  </header> <div class="docstring"><pre>Searches the given node and returns an unordered
list of child nodes at arbitrary depth that match
the given tag.</pre></div> </article> </li><li> <a name="PLUMP:HAS-ATTRIBUTE"> </a> <article id="FUNCTION PLUMP:HAS-ATTRIBUTE"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AHAS-ATTRIBUTE">HAS-ATTRIBUTE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT ATTRIBUTE</code><code>)</code>  </header> <div class="docstring"><pre>Returns T if the provided attribute exists.</pre></div> </article> </li><li> <a name="PLUMP:HAS-CHILD-NODES"> </a> <article id="FUNCTION PLUMP:HAS-CHILD-NODES"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AHAS-CHILD-NODES">HAS-CHILD-NODES</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE</code><code>)</code>  </header> <div class="docstring"><pre>Returns T if the node can contain children and
the child array is not empty.</pre></div> </article> </li><li> <a name="PLUMP:INSERT-AFTER"> </a> <article id="FUNCTION PLUMP:INSERT-AFTER"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AINSERT-AFTER">INSERT-AFTER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT NEW-CHILD</code><code>)</code>  </header> <div class="docstring"><pre>Inserts the new-child after the given element in the parent's list.
Returns the new child.

Note that this operation is potentially very costly.
See <a href="NIL">VECTOR-PUSH-EXTEND-POSITION</a></pre></div> </article> </li><li> <a name="PLUMP:INSERT-BEFORE"> </a> <article id="FUNCTION PLUMP:INSERT-BEFORE"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AINSERT-BEFORE">INSERT-BEFORE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT NEW-CHILD</code><code>)</code>  </header> <div class="docstring"><pre>Inserts the new-child before the given element in the parent's list.
Returns the new child.

Note that this operation is potentially very costly.
See <a href="NIL">VECTOR-PUSH-EXTEND-POSITION</a></pre></div> </article> </li><li> <a name="PLUMP:LAST-CHILD"> </a> <article id="FUNCTION PLUMP:LAST-CHILD"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ALAST-CHILD">LAST-CHILD</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT</code><code>)</code>  </header> <div class="docstring"><pre>Returns the last child within the parent or NIL
if the parent is empty.</pre></div> </article> </li><li> <a name="PLUMP:LAST-ELEMENT"> </a> <article id="FUNCTION PLUMP:LAST-ELEMENT"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ALAST-ELEMENT">LAST-ELEMENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT</code><code>)</code>  </header> <div class="docstring"><pre>Returns the last child element within the parent or NIL
if the parent is empty. This excludes comments, text-nodes and the like.</pre></div> </article> </li><li> <a name="PLUMP:MAKE-ATTRIBUTE-MAP"> </a> <article id="FUNCTION PLUMP:MAKE-ATTRIBUTE-MAP"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AMAKE-ATTRIBUTE-MAP">MAKE-ATTRIBUTE-MAP</a></code></h4> <code class="qualifiers"></code> <code class="arguments">&amp;OPTIONAL (SIZE 0)</code><code>)</code>  </header> <div class="docstring"><pre>Creates a map to contain attributes.</pre></div> </article> </li><li> <a name="PLUMP:MAKE-CDATA"> </a> <article id="FUNCTION PLUMP:MAKE-CDATA"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AMAKE-CDATA">MAKE-CDATA</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PARENT &amp;KEY (TEXT &quot;&quot;)</code><code>)</code>  </header> <div class="docstring"><pre>Creates an XML CDATA section under the parent.

Note that the element is automatically appended to the parent's child list.</pre></div> </article> </li><li> <a name="PLUMP:MAKE-CHILD-ARRAY"> </a> <article id="FUNCTION PLUMP:MAKE-CHILD-ARRAY"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AMAKE-CHILD-ARRAY">MAKE-CHILD-ARRAY</a></code></h4> <code class="qualifiers"></code> <code class="arguments">&amp;OPTIONAL (SIZE 0)</code><code>)</code>  </header> <div class="docstring"><pre>Creates an array to contain child elements</pre></div> </article> </li><li> <a name="PLUMP:MAKE-COMMENT"> </a> <article id="FUNCTION PLUMP:MAKE-COMMENT"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AMAKE-COMMENT">MAKE-COMMENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PARENT &amp;OPTIONAL (TEXT &quot;&quot;)</code><code>)</code>  </header> <div class="docstring"><pre>Creates a new comment node under the parent.

Note that the node is automatically appended to the parent's child list.</pre></div> </article> </li><li> <a name="PLUMP:MAKE-DOCTYPE"> </a> <article id="FUNCTION PLUMP:MAKE-DOCTYPE"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AMAKE-DOCTYPE">MAKE-DOCTYPE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PARENT DOCTYPE</code><code>)</code>  </header> <div class="docstring"><pre>Creates a new doctype node under the parent.

Note that the node is automatically appended to the parent's child list.</pre></div> </article> </li><li> <a name="PLUMP:MAKE-ELEMENT"> </a> <article id="FUNCTION PLUMP:MAKE-ELEMENT"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AMAKE-ELEMENT">MAKE-ELEMENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PARENT TAG &amp;KEY (CHILDREN (MAKE-CHILD-ARRAY))
 (ATTRIBUTES (MAKE-ATTRIBUTE-MAP))</code><code>)</code>  </header> <div class="docstring"><pre>Creates a standard DOM element with the given tag name and parent.
Optionally a vector (with fill-pointer) containing children and an
attribute-map (a hash-table with equalp test) can be supplied.

Note that the element is automatically appended to the parent's child list.</pre></div> </article> </li><li> <a name="PLUMP:MAKE-FULLTEXT-ELEMENT"> </a> <article id="FUNCTION PLUMP:MAKE-FULLTEXT-ELEMENT"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AMAKE-FULLTEXT-ELEMENT">MAKE-FULLTEXT-ELEMENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PARENT TAG &amp;KEY TEXT (ATTRIBUTES (MAKE-ATTRIBUTE-MAP))</code><code>)</code>  </header> <div class="docstring"><pre>Creates a fulltext element under the parent.
Optionally a text and an attribute-map (a hash-table with equalp test) 
can be supplied.

Note that the element is automatically appended to the parent's child list.</pre></div> </article> </li><li> <a name="PLUMP:MAKE-PROCESSING-INSTRUCTION"> </a> <article id="FUNCTION PLUMP:MAKE-PROCESSING-INSTRUCTION"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AMAKE-PROCESSING-INSTRUCTION">MAKE-PROCESSING-INSTRUCTION</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PARENT &amp;KEY NAME (TEXT &quot;&quot;)</code><code>)</code>  </header> <div class="docstring"><pre>Creates an XML processing instruction under the parent.

Note that the element is automatically appended to the parent's child list.</pre></div> </article> </li><li> <a name="PLUMP:MAKE-ROOT"> </a> <article id="FUNCTION PLUMP:MAKE-ROOT"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AMAKE-ROOT">MAKE-ROOT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">&amp;OPTIONAL (CHILDREN (MAKE-CHILD-ARRAY))</code><code>)</code>  </header> <div class="docstring"><pre>Creates a root node with the given children.
Children should be a vector with fill-pointer.</pre></div> </article> </li><li> <a name="PLUMP:MAKE-TEXT-NODE"> </a> <article id="FUNCTION PLUMP:MAKE-TEXT-NODE"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AMAKE-TEXT-NODE">MAKE-TEXT-NODE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PARENT &amp;OPTIONAL (TEXT &quot;&quot;)</code><code>)</code>  </header> <div class="docstring"><pre>Creates a new text node under the parent.

Note that the node is automatically appended to the parent's child list.</pre></div> </article> </li><li> <a name="PLUMP:MAKE-XML-HEADER"> </a> <article id="FUNCTION PLUMP:MAKE-XML-HEADER"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AMAKE-XML-HEADER">MAKE-XML-HEADER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PARENT &amp;KEY (ATTRIBUTES (MAKE-ATTRIBUTE-MAP))</code><code>)</code>  </header> <div class="docstring"><pre>Creates an XML header object under the parent.

Note that the element is automatically appended to the parent's child list.</pre></div> </article> </li><li> <a name="PLUMP:MATCHER-AND"> </a> <article id="FUNCTION PLUMP:MATCHER-AND"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AMATCHER-AND">MATCHER-AND</a></code></h4> <code class="qualifiers"></code> <code class="arguments">&amp;REST MATCHERS</code><code>)</code>  </header> <div class="docstring"><pre>Creates a matcher function that returns if all of the sub-expressions
return successfully. The last match is returned, if all.</pre></div> </article> </li><li> <a name="PLUMP:MATCHER-CHARACTER"> </a> <article id="FUNCTION PLUMP:MATCHER-CHARACTER"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AMATCHER-CHARACTER">MATCHER-CHARACTER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHARACTER</code><code>)</code>  </header> <div class="docstring"><pre>Creates a matcher function that attempts to match the given character.</pre></div> </article> </li><li> <a name="PLUMP:MATCHER-FIND"> </a> <article id="FUNCTION PLUMP:MATCHER-FIND"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AMATCHER-FIND">MATCHER-FIND</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code>  </header> <div class="docstring"><pre>Creates a matcher function that returns T if the character is found in the given list.</pre></div> </article> </li><li> <a name="PLUMP:MATCHER-NEXT"> </a> <article id="FUNCTION PLUMP:MATCHER-NEXT"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AMATCHER-NEXT">MATCHER-NEXT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">MATCHER</code><code>)</code>  </header> <div class="docstring"><pre>Creates a matcher environment that peeks ahead one farther.</pre></div> </article> </li><li> <a name="PLUMP:MATCHER-NOT"> </a> <article id="FUNCTION PLUMP:MATCHER-NOT"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AMATCHER-NOT">MATCHER-NOT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">MATCHER</code><code>)</code>  </header> <div class="docstring"><pre>Creates a matcher function that inverts the result of the sub-expression.</pre></div> </article> </li><li> <a name="PLUMP:MATCHER-OR"> </a> <article id="FUNCTION PLUMP:MATCHER-OR"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AMATCHER-OR">MATCHER-OR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">&amp;REST MATCHERS</code><code>)</code>  </header> <div class="docstring"><pre>Creates a matcher function that returns successfully if any of the
sub-expressions return successfully. The first match is returned, if any.</pre></div> </article> </li><li> <a name="PLUMP:MATCHER-PREV"> </a> <article id="FUNCTION PLUMP:MATCHER-PREV"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AMATCHER-PREV">MATCHER-PREV</a></code></h4> <code class="qualifiers"></code> <code class="arguments">MATCHER</code><code>)</code>  </header> <div class="docstring"><pre>Creates a matcher environment that peeks behind.</pre></div> </article> </li><li> <a name="PLUMP:MATCHER-RANGE"> </a> <article id="FUNCTION PLUMP:MATCHER-RANGE"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AMATCHER-RANGE">MATCHER-RANGE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">FROM TO</code><code>)</code>  </header> <div class="docstring"><pre>Creates a matcher that checks a range according to the next character's CHAR-CODE.</pre></div> </article> </li><li> <a name="PLUMP:MATCHER-STRING"> </a> <article id="FUNCTION PLUMP:MATCHER-STRING"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AMATCHER-STRING">MATCHER-STRING</a></code></h4> <code class="qualifiers"></code> <code class="arguments">STRING</code><code>)</code>  </header> <div class="docstring"><pre>Creates a matcher function that attempts to match the given string.</pre></div> </article> </li><li> <a name="PLUMP:NESTING-NODE-P"> </a> <article id="FUNCTION PLUMP:NESTING-NODE-P"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ANESTING-NODE-P">NESTING-NODE-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code>  </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type NESTING-NODE</pre></div> </article> </li><li> <a name="PLUMP:NEXT-ELEMENT"> </a> <article id="FUNCTION PLUMP:NEXT-ELEMENT"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ANEXT-ELEMENT">NEXT-ELEMENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHILD</code><code>)</code>  </header> <div class="docstring"><pre>Returns the sibling element next to this one or NIL if
it is already last. This excludes comments, text-nodes and the like.</pre></div> </article> </li><li> <a name="PLUMP:NEXT-SIBLING"> </a> <article id="FUNCTION PLUMP:NEXT-SIBLING"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ANEXT-SIBLING">NEXT-SIBLING</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHILD</code><code>)</code>  </header> <div class="docstring"><pre>Returns the sibling next to this one or NIL if
it is already the last.</pre></div> </article> </li><li> <a name="PLUMP:NODE-P"> </a> <article id="FUNCTION PLUMP:NODE-P"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ANODE-P">NODE-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code>  </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type NODE</pre></div> </article> </li><li> <a name="PLUMP:PEEK"> </a> <article id="FUNCTION PLUMP:PEEK"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3APEEK">PEEK</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code>  </header> <div class="docstring"><pre>Returns the next character, if any.</pre></div> </article> </li><li> <a name="PLUMP:PREPEND-CHILD"> </a> <article id="FUNCTION PLUMP:PREPEND-CHILD"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3APREPEND-CHILD">PREPEND-CHILD</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PARENT CHILD</code><code>)</code>  </header> <div class="docstring"><pre>Prepends the given child onto the parent's child list.
Returns the child.

Note that this operation is costly, see VECTOR-PUSH-EXTEND-FRONT</pre></div> </article> </li><li> <a name="PLUMP:PREVIOUS-ELEMENT"> </a> <article id="FUNCTION PLUMP:PREVIOUS-ELEMENT"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3APREVIOUS-ELEMENT">PREVIOUS-ELEMENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHILD</code><code>)</code>  </header> <div class="docstring"><pre>Returns the sibling element next to this one or NIL if
it is already last. This excludes comments, text-nodes and the like.</pre></div> </article> </li><li> <a name="PLUMP:PREVIOUS-SIBLING"> </a> <article id="FUNCTION PLUMP:PREVIOUS-SIBLING"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3APREVIOUS-SIBLING">PREVIOUS-SIBLING</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHILD</code><code>)</code>  </header> <div class="docstring"><pre>Returns the sibling before this one or NIL if 
it is already the first.</pre></div> </article> </li><li> <a name="PLUMP:PROCESSING-INSTRUCTION-P"> </a> <article id="FUNCTION PLUMP:PROCESSING-INSTRUCTION-P"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3APROCESSING-INSTRUCTION-P">PROCESSING-INSTRUCTION-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code>  </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type PROCESSING-INSTRUCTION</pre></div> </article> </li><li> <a name="PLUMP:READ-ATTRIBUTE"> </a> <article id="FUNCTION PLUMP:READ-ATTRIBUTE"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AREAD-ATTRIBUTE">READ-ATTRIBUTE</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code>  </header> <div class="docstring"><pre>Reads an attribute and returns it as a key value cons.</pre></div> </article> </li><li> <a name="PLUMP:READ-ATTRIBUTE-NAME"> </a> <article id="FUNCTION PLUMP:READ-ATTRIBUTE-NAME"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AREAD-ATTRIBUTE-NAME">READ-ATTRIBUTE-NAME</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code>  </header> <div class="docstring"><pre>Reads an attribute name.</pre></div> </article> </li><li> <a name="PLUMP:READ-ATTRIBUTE-VALUE"> </a> <article id="FUNCTION PLUMP:READ-ATTRIBUTE-VALUE"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AREAD-ATTRIBUTE-VALUE">READ-ATTRIBUTE-VALUE</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code>  </header> <div class="docstring"><pre>Reads an attribute value, either enclosed in quotation marks or until a space or tag end.</pre></div> </article> </li><li> <a name="PLUMP:READ-ATTRIBUTES"> </a> <article id="FUNCTION PLUMP:READ-ATTRIBUTES"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AREAD-ATTRIBUTES">READ-ATTRIBUTES</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code>  </header> <div class="docstring"><pre>Reads as many attributes as possible from a tag and returns them as an attribute map.</pre></div> </article> </li><li> <a name="PLUMP:READ-CHILDREN"> </a> <article id="FUNCTION PLUMP:READ-CHILDREN"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AREAD-CHILDREN">READ-CHILDREN</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code>  </header> <div class="docstring"><pre>Read all children of the current *root* until the closing tag for *root* is encountered.</pre></div> </article> </li><li> <a name="PLUMP:READ-NAME"> </a> <article id="FUNCTION PLUMP:READ-NAME"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AREAD-NAME">READ-NAME</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code>  </header> <div class="docstring"><pre>Reads and returns a tag name.</pre></div> </article> </li><li> <a name="PLUMP:READ-ROOT"> </a> <article id="FUNCTION PLUMP:READ-ROOT"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AREAD-ROOT">READ-ROOT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">&amp;OPTIONAL (ROOT (MAKE-ROOT))</code><code>)</code>  </header> <div class="docstring"><pre>Creates a root element and reads nodes into it.
Optionally uses the specified root to append child nodes to.
Returns the root.</pre></div> </article> </li><li> <a name="PLUMP:READ-STANDARD-TAG"> </a> <article id="FUNCTION PLUMP:READ-STANDARD-TAG"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AREAD-STANDARD-TAG">READ-STANDARD-TAG</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NAME</code><code>)</code>  </header> <div class="docstring"><pre>Reads an arbitrary tag and returns it.
This recurses with READ-CHILDREN.</pre></div> </article> </li><li> <a name="PLUMP:READ-TAG"> </a> <article id="FUNCTION PLUMP:READ-TAG"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AREAD-TAG">READ-TAG</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code>  </header> <div class="docstring"><pre>Attempts to read a tag and dispatches or defaults to READ-STANDARD-TAG.
Returns the completed node if one can be read.</pre></div> </article> </li><li> <a name="PLUMP:READ-TAG-CONTENTS"> </a> <article id="FUNCTION PLUMP:READ-TAG-CONTENTS"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AREAD-TAG-CONTENTS">READ-TAG-CONTENTS</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code>  </header> <div class="docstring"><pre>Reads and returns all tag contents. 
E.g. &lt;foo bar baz&gt; =&gt; bar baz</pre></div> </article> </li><li> <a name="PLUMP:READ-TEXT"> </a> <article id="FUNCTION PLUMP:READ-TEXT"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AREAD-TEXT">READ-TEXT</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code>  </header> <div class="docstring"><pre>Reads and returns a text-node.</pre></div> </article> </li><li> <a name="PLUMP:REMOVE-ATTRIBUTE"> </a> <article id="FUNCTION PLUMP:REMOVE-ATTRIBUTE"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AREMOVE-ATTRIBUTE">REMOVE-ATTRIBUTE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT ATTRIBUTE</code><code>)</code>  </header> <div class="docstring"><pre>Remove the specified attribute if it exists.
Returns NIL.</pre></div> </article> </li><li> <a name="PLUMP:REMOVE-CHILD"> </a> <article id="FUNCTION PLUMP:REMOVE-CHILD"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AREMOVE-CHILD">REMOVE-CHILD</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHILD</code><code>)</code>  </header> <div class="docstring"><pre>Removes the child from its parent.
Returns the child.

Note that this operation is potentially very costly.
See <a href="NIL">VECTOR-POP-POSITION</a></pre></div> </article> </li><li> <a name="PLUMP:REMOVE-PROCESSING-PARSER"> </a> <article id="FUNCTION PLUMP:REMOVE-PROCESSING-PARSER"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AREMOVE-PROCESSING-PARSER">REMOVE-PROCESSING-PARSER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PROCESS-NAME</code><code>)</code>  </header> <div class="docstring"><pre>Remove the processing-parser for PROCESS-NAME.</pre></div> </article> </li><li> <a name="PLUMP:REMOVE-TAG-DISPATCHER"> </a> <article id="FUNCTION PLUMP:REMOVE-TAG-DISPATCHER"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AREMOVE-TAG-DISPATCHER">REMOVE-TAG-DISPATCHER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NAME &amp;OPTIONAL (LIST '*ALL-TAG-DISPATCHERS*)</code><code>)</code>  </header> <div class="docstring"><pre>Removes the tag-dispatcher of the given name from the list.</pre></div> </article> </li><li> <a name="PLUMP:RENDER-TEXT"> </a> <article id="FUNCTION PLUMP:RENDER-TEXT"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ARENDER-TEXT">RENDER-TEXT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE</code><code>)</code>  </header> <div class="docstring"><pre>&quot;Renders&quot; the text of this element and its children.

In effect the text is gathered from the component and all of
its children, but transforming the text in such a way that:
- All ASCII white space (Space, Tab, CR, LF) is converted into spaces.
- There are no consecutive spaces.
- There are no spaces at the beginning or end.

This is somewhat analogous to how the text will be shown to
the user when rendered by a browser. Hence, render-text.</pre></div> </article> </li><li> <a name="PLUMP:REPLACE-CHILD"> </a> <article id="FUNCTION PLUMP:REPLACE-CHILD"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AREPLACE-CHILD">REPLACE-CHILD</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OLD-CHILD NEW-CHILD</code><code>)</code>  </header> <div class="docstring"><pre>Replace the old child with a new one.
Returns the old child.</pre></div> </article> </li><li> <a name="PLUMP:ROOT-P"> </a> <article id="FUNCTION PLUMP:ROOT-P"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AROOT-P">ROOT-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code>  </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type ROOT</pre></div> </article> </li><li> <a name="PLUMP:SERIALIZE"> </a> <article id="FUNCTION PLUMP:SERIALIZE"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ASERIALIZE">SERIALIZE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE &amp;OPTIONAL (STREAM T)</code><code>)</code>  </header> <div class="docstring"><pre>Serializes NODE to STREAM.
STREAM can be a stream, T for *standard-output* or NIL to serialize to string.</pre></div> </article> </li><li> <a name="PLUMP:SET-ATTRIBUTE"> </a> <article id="FUNCTION PLUMP:SET-ATTRIBUTE"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ASET-ATTRIBUTE">SET-ATTRIBUTE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT ATTRIBUTE VALUE</code><code>)</code>  </header> <div class="docstring"><pre>Synonymous to (SETF (ATTIBUTE ..) ..)</pre></div> </article> </li><li> <a name="PLUMP:SIBLING-ELEMENTS"> </a> <article id="FUNCTION PLUMP:SIBLING-ELEMENTS"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ASIBLING-ELEMENTS">SIBLING-ELEMENTS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHILD</code><code>)</code>  </header> <div class="docstring"><pre>Returns the array of sibling elements of the given child.
Note that this is a copy of the array, modifying it is safe.
This excludes comments, text-nodes and the like.</pre></div> </article> </li><li> <a name="PLUMP:SIBLINGS"> </a> <article id="FUNCTION PLUMP:SIBLINGS"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ASIBLINGS">SIBLINGS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHILD</code><code>)</code>  </header> <div class="docstring"><pre>Returns the array of siblings of the given child.
Note that this is a copy of the array, modifying it is safe.</pre></div> </article> </li><li> <a name="PLUMP:SLURP-STREAM"> </a> <article id="FUNCTION PLUMP:SLURP-STREAM"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ASLURP-STREAM">SLURP-STREAM</a></code></h4> <code class="qualifiers"></code> <code class="arguments">STREAM</code><code>)</code>  </header> <div class="docstring"><pre>Quickly slurps the stream's contents into an array with fill pointer.</pre></div> </article> </li><li> <a name="PLUMP:SPLICE"> </a> <article id="FUNCTION PLUMP:SPLICE"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ASPLICE">SPLICE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT</code><code>)</code>  </header> <div class="docstring"><pre>Splices the contents of element into the position of the element in its parent.
Returns the parent.

Note that this operation is potentially very costly.
See <a href="NIL">ARRAY-SHIFT</a></pre></div> </article> </li><li> <a name="PLUMP:STRIP"> </a> <article id="FUNCTION PLUMP:STRIP"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ASTRIP">STRIP</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE</code><code>)</code>  </header> <div class="docstring"><pre>Trim all text-nodes within NODE (at any depth) of leading and trailing whitespace. 
If their TEXT should be an empty string after trimming, remove them.</pre></div> </article> </li><li> <a name="PLUMP:TAG-DISPATCHER"> </a> <article id="FUNCTION PLUMP:TAG-DISPATCHER"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ATAG-DISPATCHER">TAG-DISPATCHER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NAME &amp;OPTIONAL (LIST *ALL-TAG-DISPATCHERS*)</code><code>)</code>  </header> <div class="docstring"><pre>Accessor to the tag-dispatcher of the given name.</pre></div> </article> </li><li> <a name="PLUMP:TEXT-NODE-P"> </a> <article id="FUNCTION PLUMP:TEXT-NODE-P"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ATEXT-NODE-P">TEXT-NODE-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code>  </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type TEXT-NODE</pre></div> </article> </li><li> <a name="PLUMP:TEXTUAL-NODE-P"> </a> <article id="FUNCTION PLUMP:TEXTUAL-NODE-P"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ATEXTUAL-NODE-P">TEXTUAL-NODE-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code>  </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type TEXTUAL-NODE</pre></div> </article> </li><li> <a name="PLUMP:TRANSLATE-ENTITY"> </a> <article id="FUNCTION PLUMP:TRANSLATE-ENTITY"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ATRANSLATE-ENTITY">TRANSLATE-ENTITY</a></code></h4> <code class="qualifiers"></code> <code class="arguments">TEXT &amp;KEY (START 0) (END (LENGTH TEXT))</code><code>)</code>  </header> <div class="docstring"><pre>Translates the given entity identifier (a name, #Dec or #xHex) into their respective strings if possible.
Otherwise returns NIL.</pre></div> </article> </li><li> <a name="PLUMP:TRIM"> </a> <article id="FUNCTION PLUMP:TRIM"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ATRIM">TRIM</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE</code><code>)</code>  </header> <div class="docstring"><pre>Trim all text-nodes within NODE (at any depth) of leading and trailing whitespace.</pre></div> </article> </li><li> <a name="PLUMP:UNREAD"> </a> <article id="FUNCTION PLUMP:UNREAD"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AUNREAD">UNREAD</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code>  </header> <div class="docstring"><pre>Steps back a single character if possible.
Returns the new *INDEX*.</pre></div> </article> </li><li> <a name="PLUMP:UNREAD-N"> </a> <article id="FUNCTION PLUMP:UNREAD-N"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AUNREAD-N">UNREAD-N</a></code></h4> <code class="qualifiers"></code> <code class="arguments">N</code><code>)</code>  </header> <div class="docstring"><pre>Steps back by N characters if possible.
Returns the new *INDEX*.</pre></div> </article> </li><li> <a name="PLUMP:WRITE-ENCODE-CHAR"> </a> <article id="FUNCTION PLUMP:WRITE-ENCODE-CHAR"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AWRITE-ENCODE-CHAR">WRITE-ENCODE-CHAR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHAR STREAM</code><code>)</code>  </header> <div class="docstring"><pre>Write and possibly encode the CHAR to STREAM.
This also properly handles detection of invalid or discouraged XML characters.

The following restarts are available in the case of a faulty character:
  ABORT              Do not output the faulty character at all.
  USE-NEW-CHARACTER  Output a replacement character instead.
  CONTINUE           Continue and output the faulty character anyway.

See <a href="#PLUMP-DOM:INVALID-XML-CHARACTER">INVALID-XML-CHARACTER</a>
See <a href="#PLUMP-DOM:DISCOURAGED-XML-CHARACTER">DISCOURAGED-XML-CHARACTER</a></pre></div> </article> </li><li> <a name="PLUMP:XML-HEADER-P"> </a> <article id="FUNCTION PLUMP:XML-HEADER-P"> <header class="function"> <span class="type">function</span>  <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AXML-HEADER-P">XML-HEADER-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code>  </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type XML-HEADER</pre></div> </article> </li><li> <a name="PLUMP:CLONE-NODE"> </a> <article id="GENERIC PLUMP:CLONE-NODE"> <header class="generic"> <span class="type">generic</span>  <code>(</code><h4 class="name"><code><a href="#GENERIC%20PLUMP%3ACLONE-NODE">CLONE-NODE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE &amp;OPTIONAL DEEP</code><code>)</code>  </header> <div class="docstring"><pre>Clone the given node, creating a new instance with the same contents.
If DEEP is non-NIL, the following applies:
The text of COMMENT and TEXT-NODEs is copied as per COPY-SEQ.
The children of NESTING-NODEs are copied as per (CLONE-CHILDREN CHILD T)</pre></div> </article> </li><li> <a name="PLUMP:PARSE"> </a> <article id="GENERIC PLUMP:PARSE"> <header class="generic"> <span class="type">generic</span>  <code>(</code><h4 class="name"><code><a href="#GENERIC%20PLUMP%3APARSE">PARSE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">INPUT &amp;KEY ROOT</code><code>)</code>  </header> <div class="docstring"><pre>Parses the given input into a DOM representation.
By default, methods for STRING, PATHNAME and STREAM are defined.
If supplied, the given root is used to append children to as per READ-ROOT.
Returns the root.</pre></div> </article> </li><li> <a name="PLUMP:SERIALIZE-OBJECT"> </a> <article id="GENERIC PLUMP:SERIALIZE-OBJECT"> <header class="generic"> <span class="type">generic</span>  <code>(</code><h4 class="name"><code><a href="#GENERIC%20PLUMP%3ASERIALIZE-OBJECT">SERIALIZE-OBJECT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE</code><code>)</code>  </header> <div class="docstring"><pre>Serialize the given node and print it to *stream*.</pre></div> </article> </li><li> <a name="PLUMP:TRAVERSE"> </a> <article id="GENERIC PLUMP:TRAVERSE"> <header class="generic"> <span class="type">generic</span>  <code>(</code><h4 class="name"><code><a href="#GENERIC%20PLUMP%3ATRAVERSE">TRAVERSE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE FUNCTION &amp;KEY TEST</code><code>)</code>  </header> <div class="docstring"><pre>Traverse the NODE and all its children recursively,
calling FUNCTION on the current node if calling TEST on the current node
returns a non-NIL value. It is safe to modify the child array of the
parent of each node passed to FUNCTION.

NODE is returned.</pre></div> </article> </li><li> <a name="PLUMP:DEFINE-FULLTEXT-ELEMENT"> </a> <article id="MACRO PLUMP:DEFINE-FULLTEXT-ELEMENT"> <header class="macro"> <span class="type">macro</span>  <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP%3ADEFINE-FULLTEXT-ELEMENT">DEFINE-FULLTEXT-ELEMENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">TAG &amp;REST LISTS</code><code>)</code>  </header> <div class="docstring"><pre>Defines an element to be read as a full-text element.
This means that it cannot contain any child-nodes and everything up until its closing
tag is used as its text.</pre></div> </article> </li><li> <a name="PLUMP:DEFINE-MATCHER"> </a> <article id="MACRO PLUMP:DEFINE-MATCHER"> <header class="macro"> <span class="type">macro</span>  <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP%3ADEFINE-MATCHER">DEFINE-MATCHER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NAME FORM</code><code>)</code>  </header> <div class="docstring"><pre>Associates NAME as a keyword to the matcher form. You can then use the keyword in further matcher rules.</pre></div> </article> </li><li> <a name="PLUMP:DEFINE-PROCESSING-PARSER"> </a> <article id="MACRO PLUMP:DEFINE-PROCESSING-PARSER"> <header class="macro"> <span class="type">macro</span>  <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP%3ADEFINE-PROCESSING-PARSER">DEFINE-PROCESSING-PARSER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PROCESS-NAME NIL &amp;BODY BODY</code><code>)</code>  </header> <div class="docstring"><pre>Defines a new processing-instruction parser. 
It is invoked if a processing-instruction (&lt;?) with PROCESS-NAME is encountered.
The lexer will be at the point straight after reading in the PROCESS-NAME.
Expected return value is a string to use as the processing-instructions' TEXT.
The closing tag (?&gt;) should NOT be consumed by a processing-parser.</pre></div> </article> </li><li> <a name="PLUMP:DEFINE-SELF-CLOSING-ELEMENT"> </a> <article id="MACRO PLUMP:DEFINE-SELF-CLOSING-ELEMENT"> <header class="macro"> <span class="type">macro</span>  <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP%3ADEFINE-SELF-CLOSING-ELEMENT">DEFINE-SELF-CLOSING-ELEMENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">TAG &amp;REST LISTS</code><code>)</code>  </header> <div class="docstring"><pre>Defines an element that does not need to be closed with /&gt; and cannot contain child nodes.</pre></div> </article> </li><li> <a name="PLUMP:DEFINE-TAG-DISPATCHER"> </a> <article id="MACRO PLUMP:DEFINE-TAG-DISPATCHER"> <header class="macro"> <span class="type">macro</span>  <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP%3ADEFINE-TAG-DISPATCHER">DEFINE-TAG-DISPATCHER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">(NAME &amp;REST LISTS) (TAGVAR) &amp;BODY BODY</code><code>)</code>  </header> <div class="docstring"><pre>Defines a new tag dispatcher. It is invoked if TEST-FORM passes.

NAME      --- Name to discern the dispatcher with.
LISTS     --- Symbols of lists to which the dispatcher should be added.
TAGVAR    --- Symbol bound to the tag name.
BODY      --- Body forms describing the test to match the tag.</pre></div> </article> </li><li> <a name="PLUMP:DEFINE-TAG-PARSER"> </a> <article id="MACRO PLUMP:DEFINE-TAG-PARSER"> <header class="macro"> <span class="type">macro</span>  <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP%3ADEFINE-TAG-PARSER">DEFINE-TAG-PARSER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NAME (TAGVAR) &amp;BODY BODY</code><code>)</code>  </header> <div class="docstring"><pre>Defines the parser function for a tag dispatcher.

NAME    --- The name of the tag dispatcher. If one with this name 
            cannot be found, an error is signalled.
TAGVAR  --- Symbol bound to the tag name.
BODY    --- Body forms describing the tag parsing behaviour.</pre></div> </article> </li><li> <a name="PLUMP:DEFINE-TAG-PRINTER"> </a> <article id="MACRO PLUMP:DEFINE-TAG-PRINTER"> <header class="macro"> <span class="type">macro</span>  <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP%3ADEFINE-TAG-PRINTER">DEFINE-TAG-PRINTER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NAME (NODEVAR) &amp;BODY BODY</code><code>)</code>  </header> <div class="docstring"><pre>Defines the printer function for a tag dispatcher.

NAME    --- The name of the tag dispatcher. If one with this name 
            cannot be found, an error is signalled.
TAGVAR  --- Symbol bound to the tag name.
BODY    --- Body forms describing the printing behaviour. Write to
            the stream bound to PLUMP-DOM:*STREAM*.</pre></div> </article> </li><li> <a name="PLUMP:DO-TAG-PARSERS"> </a> <article id="MACRO PLUMP:DO-TAG-PARSERS"> <header class="macro"> <span class="type">macro</span>  <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP%3ADO-TAG-PARSERS">DO-TAG-PARSERS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">(TEST PARSER &amp;OPTIONAL RESULT-FORM) &amp;BODY BODY</code><code>)</code>  </header> <div class="docstring"><pre>Iterates over the current *TAG-DISPATCHERS*, binding the TEST and PARSER functions.
Returns RESULT-FORM's evaluated value.</pre></div> </article> </li><li> <a name="PLUMP:DO-TAG-PRINTERS"> </a> <article id="MACRO PLUMP:DO-TAG-PRINTERS"> <header class="macro"> <span class="type">macro</span>  <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP%3ADO-TAG-PRINTERS">DO-TAG-PRINTERS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">(TEST PRINTER &amp;OPTIONAL RESULT-FORM) &amp;BODY BODY</code><code>)</code>  </header> <div class="docstring"><pre>Iterates over the current *TAG-DISPATCHERS*, binding the TEST and PRINTER functions.
Returns RESULT-FORM's evaluated value.</pre></div> </article> </li><li> <a name="PLUMP:MAKE-MATCHER"> </a> <article id="MACRO PLUMP:MAKE-MATCHER"> <header class="macro"> <span class="type">macro</span>  <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP%3AMAKE-MATCHER">MAKE-MATCHER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">FORM</code><code>)</code>  </header> <div class="docstring"><pre>Macro to create a matcher chain.</pre></div> </article> </li><li> <a name="PLUMP:MATCHER-ANY"> </a> <article id="MACRO PLUMP:MATCHER-ANY"> <header class="macro"> <span class="type">macro</span>  <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP%3AMATCHER-ANY">MATCHER-ANY</a></code></h4> <code class="qualifiers"></code> <code class="arguments">&amp;REST IS</code><code>)</code>  </header> <div class="docstring"><pre>Shorthand for (or (is a) (is b)..)</pre></div> </article> </li><li> <a name="PLUMP:WITH-LEXER-ENVIRONMENT"> </a> <article id="MACRO PLUMP:WITH-LEXER-ENVIRONMENT"> <header class="macro"> <span class="type">macro</span>  <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP%3AWITH-LEXER-ENVIRONMENT">WITH-LEXER-ENVIRONMENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">(STRING) &amp;BODY BODY</code><code>)</code>  </header> <div class="docstring"><pre>Sets up the required lexing environment for the given string.</pre></div> </article> </li></ul> </li></ul> </article>  </main> </body> </html> 